// Tauri 应用的主JavaScript文件
console.log('Tauri 应用正在启动...');

// 处理窗口显示和加载遮罩
// Blue Code 主JavaScript文件
console.log('Blue Code 已启动');

// 立即检查Tauri API是否可用
console.log('检查Tauri API状态...');
console.log('window.__TAURI__:', window.__TAURI__);
console.log('window.__TAURI__.core:', window.__TAURI__?.core);
console.log('window.__TAURI__.core.invoke:', window.__TAURI__?.core?.invoke);

// 简化的窗口显示函数
async function showWindow() {
  console.log('showWindow 函数被调用');
  console.log('Tauri API 状态:', {
    hasTauri: !!window.__TAURI__,
    hasCore: !!(window.__TAURI__ && window.__TAURI__.core),
    hasInvoke: !!(window.__TAURI__ && window.__TAURI__.core && window.__TAURI__.core.invoke)
  });
  
  try {
    if (window.__TAURI__ && window.__TAURI__.core) {
      // 首先测试一个简单的命令
      console.log('测试Tauri API连接...');
      try {
        const result = await window.__TAURI__.core.invoke('greet', { name: 'test' });
        console.log('Tauri API测试成功:', result);
      } catch (testError) {
        console.error('Tauri API测试失败:', testError);
      }
      
      console.log('调用 notify_page_ready 命令...');
      // 调用Rust后端命令来显示窗口，传递当前窗口对象
      await window.__TAURI__.core.invoke('notify_page_ready');
      console.log('窗口显示成功');
    } else {
      console.log('Tauri API 不可用');
    }
  } catch (error) {
    console.error('显示窗口时出错:', error);
  }
}

// 页面加载状态跟踪
let pageFullyLoaded = false;
let windowShown = false;
let initializationComplete = false;

// 确保只显示一次窗口
async function ensureWindowShown() {
  if (windowShown) {
    console.log('窗口已经显示过，跳过');
    return;
  }
  
  if (pageFullyLoaded && initializationComplete) {
    console.log('页面已完全加载且初始化完成，等待额外延迟后显示窗口');
    // 添加额外延迟，确保页面完全稳定
    setTimeout(async () => {
      if (!windowShown) {
        console.log('延迟结束，显示窗口');
        windowShown = true;
        await showWindow();
      }
    }, 500); // 500毫秒延迟
  } else {
    console.log('等待条件满足:', { pageFullyLoaded, initializationComplete });
  }
}

// 页面加载完成后显示窗口
document.addEventListener('DOMContentLoaded', () => {
  console.log('DOMContentLoaded 事件触发');
  // DOM加载完成，但可能还有资源在加载
});

window.addEventListener('load', () => {
  console.log('load 事件触发 - 所有资源已加载');
  pageFullyLoaded = true;
  ensureWindowShown();
});

// 额外的加载检测：确保所有图片、样式表等都加载完毕
window.addEventListener('beforeunload', () => {
  console.log('页面即将卸载');
});

// 如果页面已经加载完成，立即显示窗口
if (document.readyState === 'complete') {
  console.log('页面已经完成加载');
  pageFullyLoaded = true;
  ensureWindowShown();
}

// 全局变量
let currentFile = null;
let isFileModified = false;
let terminalWorkingDir = '';
let fileSystem;

// 处理菜单动作
function handleMenuAction(action) {
  console.log('handleMenuAction 被调用，action:', action);
  switch (action) {
    case 'new-file':
      createNewFile();
      break;
    case 'open-file':
      openFile();
      break;
    case 'open-folder':
      openFolder();
      break;
    case 'save':
      saveCurrentFile();
      break;
    case 'save-as':
      saveFileAs();
      break;
    case 'exit':
      window.__TAURI__.app.exit();
      break;
    case 'undo':
      document.execCommand('undo');
      break;
    case 'redo':
      document.execCommand('redo');
      break;
    case 'cut':
      document.execCommand('cut');
      break;
    case 'copy':
      document.execCommand('copy');
      break;
    case 'paste':
      document.execCommand('paste');
      break;
    case 'find':
      showFindDialog();
      break;
    case 'replace':
      showReplaceDialog();
      break;
    case 'select-all':
      document.execCommand('selectAll');
      break;
    case 'expand-selection':
      expandSelection();
      break;
    case 'shrink-selection':
      shrinkSelection();
      break;
    case 'toggle-sidebar':
      toggleSidebar();
      break;
    case 'toggle-terminal':
      toggleTerminal();
      break;
    case 'zoom-in':
      zoomIn();
      break;
    case 'zoom-out':
      zoomOut();
      break;
    case 'reset-zoom':
      resetZoom();
      break;
    case 'start-debugging':
      startDebugging();
      break;
    case 'start-without-debugging':
      startWithoutDebugging();
      break;
    case 'stop':
      stopExecution();
      break;
    case 'restart':
      restartExecution();
      break;
    case 'new-terminal':
      createNewTerminal();
      break;
    case 'split-terminal':
      splitTerminal();
      break;
    case 'clear-terminal':
      clearTerminal();
      break;
    case 'kill-terminal':
      killTerminal();
      break;
    case 'welcome':
      showWelcome();
      break;
    case 'documentation':
      showDocumentation();
      break;
    case 'about':
      showAbout();
      break;
    default:
      console.log('未知的菜单动作:', action);
  }
}

// 导入Tauri API
const { invoke } = window.__TAURI__.core;

// 活动栏切换功能
document.addEventListener('DOMContentLoaded', () => {
  const activityItems = document.querySelectorAll('.activity-item');
  const sidebarPanels = document.querySelectorAll('.sidebar-panel');

  activityItems.forEach(item => {
    item.addEventListener('click', () => {
      // 移除所有活动状态
      activityItems.forEach(i => i.classList.remove('active'));
      sidebarPanels.forEach(p => p.classList.remove('active'));

      // 添加当前活动状态
      item.classList.add('active');
      const panelId = item.getAttribute('data-panel') + '-panel';
      const panel = document.getElementById(panelId);
      if (panel) {
        panel.classList.add('active');
      }
    });
  });

  // 编辑器功能
  let codeEditor = document.getElementById('code-editor');

  // 文件资源管理器交互（现在由FileSystem类处理）

  // 编辑器功能
  if (codeEditor) {
    // 获取code元素
    const codeElement = codeEditor.querySelector('code');
    
    // 初始化编辑器布局
    initializeEditorLayout();
    
    // 自动调整行号 - 使用防抖优化性能
    let lineNumberUpdateTimeout;
    codeEditor.addEventListener('input', () => {
      // 清除之前的定时器
      clearTimeout(lineNumberUpdateTimeout);
      // 延迟更新行号，避免频繁更新
      lineNumberUpdateTimeout = setTimeout(() => {
        updateLineNumbers();
        preciseAlignLineNumbers(); // 确保精确对齐
        // 实时更新代码高亮
        if (fileSystem && fileSystem.currentFile) {
          fileSystem.applySyntaxHighlighting(codeElement.textContent);
        }
      }, 100); // 100ms防抖
    });
    codeEditor.addEventListener('scroll', syncScroll);
    codeEditor.addEventListener('paste', (e) => {
      // 阻止默认粘贴行为，手动处理
      e.preventDefault();
      const text = e.clipboardData.getData('text/plain');
      document.execCommand('insertText', false, text);
      
      // 粘贴后立即更新行号
      setTimeout(() => {
        updateLineNumbers();
        preciseAlignLineNumbers(); // 确保精确对齐
        // 粘贴后更新代码高亮
        if (fileSystem && fileSystem.currentFile) {
          fileSystem.applySyntaxHighlighting(codeElement.textContent);
        }
      }, 0);
    });
    codeEditor.addEventListener('wheel', syncScroll);
    codeEditor.addEventListener('mousewheel', syncScroll);
    codeEditor.addEventListener('DOMMouseScroll', syncScroll);
    
    // 监听滚动条拖拽
    codeEditor.addEventListener('mousedown', () => {
      const handleMouseMove = () => {
        syncScroll();
        requestAnimationFrame(handleMouseMove);
      };
      handleMouseMove();
      
      const handleMouseUp = () => {
        document.removeEventListener('mousemove', handleMouseMove);
        document.removeEventListener('mouseup', handleMouseUp);
      };
      document.addEventListener('mousemove', handleMouseMove);
      document.addEventListener('mouseup', handleMouseUp);
    });
    codeEditor.addEventListener('keydown', (e) => {
      // 监听回车键和删除键
      if (e.key === 'Enter' || e.key === 'Backspace' || e.key === 'Delete') {
        setTimeout(() => {
          updateLineNumbers();
          preciseAlignLineNumbers(); // 确保精确对齐
          // 更新代码高亮
          if (fileSystem && fileSystem.currentFile) {
            fileSystem.applySyntaxHighlighting(codeElement.textContent);
          }
        }, 0);
      }
      // 监听键盘滚动键
      if (e.key === 'ArrowUp' || e.key === 'ArrowDown' || e.key === 'PageUp' || e.key === 'PageDown' || e.key === 'Home' || e.key === 'End') {
        setTimeout(syncScroll, 0);
      }
    });
      // 监听内容变化（包括通过JavaScript设置内容）
  const observer = new MutationObserver(() => {
    updateLineNumbers();
  });
  observer.observe(codeEditor, {
    childList: true,
    subtree: true,
    characterData: true
  });
    // 初始化行号（空编辑器）
    updateLineNumbers();
    // 清空编辑器内容
    if (codeElement) {
      codeElement.textContent = '';
      codeElement.className = 'language-plaintext';
    }
    console.log('编辑器初始化完成');
  }

  // 标题栏交互
  const windowControls = document.querySelectorAll('.window-control');
  windowControls.forEach(control => {
    control.addEventListener('click', async () => {
      try {
        if (control.classList.contains('close')) {
          await window.__TAURI__.window.getCurrent().close();
        } else if (control.classList.contains('minimize')) {
          await window.__TAURI__.window.getCurrent().minimize();
        } else if (control.classList.contains('maximize')) {
          await window.__TAURI__.window.getCurrent().toggleMaximize();
        }
      } catch (error) {
        console.error('窗口操作失败:', error);
        // 备用方案：尝试使用不同的API调用方式
        try {
          const currentWindow = window.__TAURI__.window.getCurrent();
          if (control.classList.contains('close')) {
            await currentWindow.close();
          } else if (control.classList.contains('minimize')) {
            await currentWindow.minimize();
          } else if (control.classList.contains('maximize')) {
            await currentWindow.toggleMaximize();
          }
        } catch (fallbackError) {
          console.error('备用方案也失败:', fallbackError);
          // 最后的备用方案：使用Rust后端命令
          try {
            if (control.classList.contains('close')) {
              await window.__TAURI__.core.invoke('close_window');
            } else if (control.classList.contains('minimize')) {
              await window.__TAURI__.core.invoke('minimize_window');
            } else if (control.classList.contains('maximize')) {
              await window.__TAURI__.core.invoke('toggle_maximize_window');
            }
          } catch (finalError) {
            console.error('所有方案都失败:', finalError);
          }
        }
      }
    });
  });

  // 标题栏右侧操作
  const titleBarActions = document.querySelectorAll('.title-bar-actions i');
  titleBarActions.forEach(action => {
    action.addEventListener('click', () => {
      const title = action.getAttribute('title');
      console.log('标题栏操作:', title);
      // 这里可以添加标题栏操作功能
    });
  });

  // 菜单栏交互 - 由 initializeMenuBar() 函数处理

  // 状态栏交互
  const statusItems = document.querySelectorAll('.status-item');
  statusItems.forEach(item => {
    item.addEventListener('click', () => {
      console.log('状态栏项点击:', item.textContent);
      // 这里可以添加状态栏功能
    });
  });

  // 初始化文件系统
  console.log('初始化文件系统...');
  fileSystem = new FileSystem();
  fileSystem.initialize().then(() => {
    console.log('文件系统初始化完成');
  }).catch(error => {
    console.error('文件系统初始化失败:', error);
  });

  // 初始化终端
  console.log('初始化终端...');
  initTerminal().then(() => {
    console.log('终端初始化完成');
  }).catch(error => {
    console.error('终端初始化失败:', error);
  });

  // 初始化侧边栏拖拽调整器
  console.log('初始化侧边栏拖拽调整器...');
  initSidebarResizer();

  // 初始化右键菜单
  console.log('初始化右键菜单...');
  initContextMenu();

  // 初始化菜单栏
  console.log('初始化菜单栏...');
  initializeMenuBar();

  // 初始化代码高亮
  console.log('初始化代码高亮...');
  initializeCodeEditor();

  // 初始化标签页滚动功能
  console.log('初始化标签页滚动功能...');
  initTabScrolling();

  console.log('所有初始化完成');
  
  // 添加简单的测试函数
  window.testLineNumbers = function() {
    console.log('=== 行号测试 ===');
    updateLineNumbers();
    preciseAlignLineNumbers(); // 确保精确对齐
    console.log('=== 测试完成 ===');
  };
  
  // 添加行号对齐验证函数
  window.verifyLineNumberAlignment = function() {
    console.log('=== 验证行号对齐 ===');
    let codeEditor = document.getElementById('code-editor');
    const lineNumbers = document.querySelector('.line-numbers');
    
    if (!codeEditor || !lineNumbers) {
      console.log('找不到编辑器或行号容器');
      return;
    }
    
    const codeElement = codeEditor.querySelector('code');
    const lines = codeElement ? codeElement.textContent.split('\n') : [];
    const lineCount = lines.length;
    
    console.log('编辑器信息:', {
      lineCount,
      editorPadding: '10px',
      lineHeight: '21px',
      editorHeight: codeEditor.offsetHeight,
      editorScrollHeight: codeEditor.scrollHeight
    });
    
    const lineNumberElements = lineNumbers.querySelectorAll('.line-number');
    console.log('行号信息:', {
      lineNumberCount: lineNumberElements.length,
      lineNumbersHeight: lineNumbers.offsetHeight,
      lineNumbersPadding: window.getComputedStyle(lineNumbers).padding
    });
    
    if (lineNumberElements.length > 0) {
      const firstLineNumber = lineNumberElements[0];
      const firstLineRect = firstLineNumber.getBoundingClientRect();
      const lineNumbersRect = lineNumbers.getBoundingClientRect();
      const codeRect = codeElement.getBoundingClientRect();
      
      console.log('第一行对齐检查:', {
        lineNumberTop: firstLineRect.top,
        lineNumbersTop: lineNumbersRect.top,
        codeTop: codeRect.top,
        lineNumberTopStyle: firstLineNumber.style.top,
        expectedAlignment: Math.abs(firstLineRect.top - codeRect.top) <= 1
      });
      
      // 检查前几行的位置
      const checkLines = Math.min(5, lineNumberElements.length);
      for (let i = 0; i < checkLines; i++) {
        const lineNumber = lineNumberElements[i];
        const topStyle = lineNumber.style.top;
        const expectedTop = i * 21 + 10;
        console.log(`行号 ${i + 1}:`, {
          topStyle,
          expectedTop,
          isCorrect: topStyle === expectedTop + 'px'
        });
      }
    }
    
    console.log('=== 验证完成 ===');
  };
  
  // 监听窗口大小变化
  window.addEventListener('resize', () => {
    setTimeout(() => {
      initializeEditorLayout();
      updateLineNumbers();
      preciseAlignLineNumbers(); // 确保精确对齐
      ensureScrollSync();
      forceRecalculateEditorScroll();
      // 强制同步行号容器高度
      forceSyncLineNumbersHeight();
      // 更新图片预览容器高度
      updateImagePreviewHeight();
    }, 100);
  });
  
  // 显示窗口
  console.log('准备显示窗口...');
  showWindow();
});



// VSCode风格的行号更新
function updateLineNumbers() {
  let codeEditor = document.getElementById('code-editor');
  const lineNumbers = document.querySelector('.line-numbers');
  
  if (!codeEditor || !lineNumbers) return;

  const codeElement = codeEditor.querySelector('code');
  const lines = codeElement ? codeElement.textContent.split('\n') : [];
  const lineCount = lines.length;
  
  // 获取计算样式以确保一致性
  const computedStyle = window.getComputedStyle(codeElement);
  const lineHeight = parseInt(computedStyle.lineHeight) || 21;
  const fontSize = parseInt(computedStyle.fontSize) || 14;
  
  // 确保至少有一行
  if (lineCount === 0) {
    lineNumbers.innerHTML = '<div class="line-number">1</div>';
    lineNumbers.style.height = '31px'; // 10px padding + 21px line height
    return;
  }
  
  // 清空现有行号
  lineNumbers.innerHTML = '';
  
  // 创建文档片段以提高性能
  const fragment = document.createDocumentFragment();
  
  // 添加新的行号，VSCode风格
  for (let i = 1; i <= lineCount; i++) {
    const lineDiv = document.createElement('div');
    lineDiv.className = 'line-number';
    lineDiv.textContent = i;
    lineDiv.setAttribute('data-line', i);
    
    // VSCode风格的位置计算
    // 第一行从10px开始（与code元素的padding-top对齐）
    const topPosition = (i - 1) * lineHeight + 10;
    lineDiv.style.position = 'absolute';
    lineDiv.style.top = topPosition + 'px';
    lineDiv.style.left = '0';
    lineDiv.style.right = '0';
    lineDiv.style.height = lineHeight + 'px';
    lineDiv.style.lineHeight = lineHeight + 'px';
    lineDiv.style.fontSize = fontSize + 'px';
    
    // 添加点击事件（可选，用于跳转到指定行）
    lineDiv.addEventListener('click', () => {
      // 可以在这里添加跳转到指定行的功能
      console.log('点击行号:', i);
    });
    
    fragment.appendChild(lineDiv);
  }
  
  lineNumbers.appendChild(fragment);
  
  // 设置行号容器高度与编辑器内容匹配
  const totalHeight = lineCount * lineHeight + 20; // 20px是编辑器的上下padding总和
  lineNumbers.style.height = totalHeight + 'px';
  
  // 同步滚动位置
  syncLineNumbersScroll();
}

// 强制同步行号容器高度
function forceSyncLineNumbersHeight() {
  let codeEditor = document.getElementById('code-editor');
  const lineNumbers = document.querySelector('.line-numbers');
  
  if (!codeEditor || !lineNumbers) return;
  
  const codeElement = codeEditor.querySelector('code');
  if (!codeElement) return;
  
  // 获取计算样式以确保一致性
  const computedStyle = window.getComputedStyle(codeElement);
  const lineHeight = parseInt(computedStyle.lineHeight) || 21;
  
  // 获取编辑器的实际滚动高度
  const editorScrollHeight = codeEditor.scrollHeight;
  const lineNumbersHeight = lineNumbers.offsetHeight;
  
  // 计算预期的行号容器高度
  const lines = codeElement.textContent.split('\n');
  const lineCount = lines.length;
  const expectedHeight = lineCount * lineHeight + 20; // 20px是编辑器的上下padding总和
  
  // 如果高度不匹配，强制设置
  if (Math.abs(editorScrollHeight - lineNumbersHeight) > 1 || Math.abs(expectedHeight - lineNumbersHeight) > 1) {
    console.log('强制同步行号容器高度:', {
      editorScrollHeight,
      lineNumbersHeight,
      expectedHeight,
      lineCount,
      lineHeight
    });
    
    // 强制设置行号容器高度
    lineNumbers.style.height = expectedHeight + 'px';
    
    // 验证设置是否成功
    setTimeout(() => {
      const newHeight = lineNumbers.offsetHeight;
      console.log('高度同步结果:', {
        targetHeight: expectedHeight,
        actualHeight: newHeight,
        success: Math.abs(expectedHeight - newHeight) <= 1
      });
    }, 10);
  }
}

// 验证行号对齐是否正确
function validateLineNumberAlignment() {
  let codeEditor = document.getElementById('code-editor');
  const lineNumbers = document.querySelector('.line-numbers');
  
  if (!codeEditor || !lineNumbers) return;
  
  const codeElement = codeEditor.querySelector('code');
  const lines = codeElement ? codeElement.textContent.split('\n') : [];
  const lineCount = lines.length;
  
  if (lineCount === 0) return;
  
  // 获取计算样式以确保一致性
  const computedStyle = window.getComputedStyle(codeElement);
  const lineHeight = parseInt(computedStyle.lineHeight) || 21;
  
  // 检查前几行的对齐情况
  const checkLines = Math.min(5, lineCount);
  console.log('验证行号对齐:', {
    totalLines: lineCount,
    checkingLines: checkLines,
    editorPadding: 10,
    lineHeight: lineHeight
  });
  
  let allAligned = true;
  
  for (let i = 1; i <= checkLines; i++) {
    const lineNumber = lineNumbers.querySelector(`.line-number:nth-child(${i})`);
    if (lineNumber) {
      const topPosition = parseInt(lineNumber.style.top) || 0;
      const expectedTop = (i - 1) * lineHeight + 10;
      const isAligned = Math.abs(topPosition - expectedTop) <= 1;
      
      if (!isAligned) {
        allAligned = false;
        // 立即修正位置
        lineNumber.style.top = expectedTop + 'px';
      }
      
      console.log(`行 ${i} 对齐检查:`, {
        actualTop: topPosition,
        expectedTop: expectedTop,
        isAligned: isAligned,
        difference: topPosition - expectedTop
      });
    }
  }
  
  console.log('所有行号对齐状态:', allAligned);
  
  // 如果对齐有问题，尝试重新计算
  if (!allAligned) {
    console.log('检测到行号对齐问题，已进行修正');
  }
}

// 调试编辑器内容位置
function debugEditorContentPosition() {
  let codeEditor = document.getElementById('code-editor');
  const lineNumbers = document.querySelector('.line-numbers');
  
  if (!codeEditor || !lineNumbers) return;
  
  const codeElement = codeEditor.querySelector('code');
  if (!codeElement) return;
  
  // 获取编辑器内容的位置信息
  const editorRect = codeEditor.getBoundingClientRect();
  const codeRect = codeElement.getBoundingClientRect();
  const lineNumbersRect = lineNumbers.getBoundingClientRect();
  
  console.log('编辑器位置调试:', {
    editorTop: editorRect.top,
    editorLeft: editorRect.left,
    editorPadding: 10,
    codeTop: codeRect.top,
    codeLeft: codeRect.left,
    lineNumbersTop: lineNumbersRect.top,
    lineNumbersLeft: lineNumbersRect.left,
    editorScrollTop: codeEditor.scrollTop,
    editorScrollHeight: codeEditor.scrollHeight,
    lineNumbersHeight: lineNumbers.offsetHeight
  });
  
  // 检查第一行文本的实际位置
  const firstLineNumber = lineNumbers.querySelector('.line-number:first-child');
  if (firstLineNumber) {
    const firstLineRect = firstLineNumber.getBoundingClientRect();
    console.log('第一行行号位置:', {
      top: firstLineRect.top,
      left: firstLineRect.left,
      expectedTop: lineNumbersRect.top + 10, // 行号容器顶部 + 10px padding
      difference: firstLineRect.top - (lineNumbersRect.top + 10)
    });
  }
  
  // 检查编辑器内容的实际位置
  const computedStyle = window.getComputedStyle(codeEditor);
  console.log('编辑器计算样式:', {
    paddingTop: computedStyle.paddingTop,
    paddingBottom: computedStyle.paddingBottom,
    marginTop: computedStyle.marginTop,
    marginBottom: computedStyle.marginBottom,
    lineHeight: computedStyle.lineHeight,
    fontSize: computedStyle.fontSize
  });
  
  // 检查code元素的样式
  const codeComputedStyle = window.getComputedStyle(codeElement);
  console.log('Code元素计算样式:', {
    paddingTop: codeComputedStyle.paddingTop,
    paddingBottom: codeComputedStyle.paddingBottom,
    marginTop: codeComputedStyle.marginTop,
    marginBottom: codeComputedStyle.marginBottom,
    lineHeight: codeComputedStyle.lineHeight,
    fontSize: codeComputedStyle.fontSize
  });
}

// 同步滚动
function syncScroll() {
  syncLineNumbersScroll();
}

// VSCode风格的滚动同步
function syncLineNumbersScroll() {
  let codeEditor = document.getElementById('code-editor');
  const lineNumbers = document.querySelector('.line-numbers');
  
  if (!codeEditor || !lineNumbers) return;
  
  // VSCode风格：使用transform实现平滑滚动同步
  const scrollTop = codeEditor.scrollTop;
  lineNumbers.style.transform = `translateY(-${scrollTop}px)`;
  
  // 可选：添加当前行高亮功能
  highlightCurrentLine();
}

// VSCode风格的当前行高亮
function highlightCurrentLine() {
  let codeEditor = document.getElementById('code-editor');
  const lineNumbers = document.querySelector('.line-numbers');
  
  if (!codeEditor || !lineNumbers) return;
  
  // 移除所有当前行高亮
  const currentLines = lineNumbers.querySelectorAll('.line-number.current-line');
  currentLines.forEach(line => line.classList.remove('current-line'));
  
  // 计算当前行（基于滚动位置和光标位置）
  const scrollTop = codeEditor.scrollTop;
  const lineHeight = 21;
  const paddingTop = 10;
  
  // 简单的当前行计算（可以进一步优化）
  const currentLineIndex = Math.floor((scrollTop + codeEditor.clientHeight / 2 - paddingTop) / lineHeight) + 1;
  
  // 高亮当前行
  const currentLineElement = lineNumbers.querySelector(`[data-line="${currentLineIndex}"]`);
  if (currentLineElement) {
    currentLineElement.classList.add('current-line');
  }
}

// 强制重新对齐行号与编辑器内容
function forceRealignLineNumbers() {
  // 这个函数现在不需要做任何事情，因为CSS已经处理了布局
  console.log('强制重新对齐完成');
}

// 确保滚动同步的辅助函数
function ensureScrollSync() {
  let codeEditor = document.getElementById('code-editor');
  const lineNumbers = document.querySelector('.line-numbers');
  
  if (codeEditor && lineNumbers) {
    // 使用transform同步滚动
    syncLineNumbersScroll();
    
    // 强制重新计算编辑器滚动区域
    forceRecalculateEditorScroll();
    
    // 调试信息
    console.log('Scroll sync:', {
      editorScrollTop: codeEditor.scrollTop,
      lineNumbersTransform: lineNumbers.style.transform,
      editorScrollHeight: codeEditor.scrollHeight,
      lineNumbersHeight: lineNumbers.offsetHeight
    });
  }
}

// 强制重新计算编辑器滚动区域
function forceRecalculateEditorScroll() {
  let codeEditor = document.getElementById('code-editor');
  const codeContent = document.querySelector('.code-content');
  
  if (codeEditor && codeContent) {
    // 获取代码元素
    const codeElement = codeEditor.querySelector('code');
    if (codeElement) {
      // 计算实际内容高度
      const content = codeElement.textContent;
      const lines = content.split('\n');
      const lineHeight = 21; // 与CSS中的line-height一致
      const contentHeight = Math.max(lines.length * lineHeight, window.innerHeight - 200);
      
      // 确保编辑器容器有正确的高度
      codeEditor.style.height = '100%';
      codeEditor.style.minHeight = '';
      codeEditor.style.maxHeight = '';
      
      // 确保代码内容区域有正确的高度
      codeContent.style.height = '100%';
      codeContent.style.minHeight = '';
      codeContent.style.maxHeight = '';
      
      // 确保代码元素有正确的高度
      codeElement.style.height = '';
      codeElement.style.minHeight = '';
      codeElement.style.maxHeight = '';
      
      // 强制重新计算布局
      codeEditor.offsetHeight; // 触发重排
      
      // 强制重新对齐行号
      forceRealignLineNumbers();
      
      console.log('强制重新计算编辑器滚动区域:', {
        contentLines: lines.length,
        calculatedHeight: contentHeight,
        editorScrollHeight: codeEditor.scrollHeight,
        editorClientHeight: codeEditor.clientHeight,
        contentScrollHeight: codeContent.scrollHeight,
        contentClientHeight: codeContent.clientHeight
      });
    }
  }
}

// VSCode风格的精确对齐
function preciseAlignLineNumbers() {
  let codeEditor = document.getElementById('code-editor');
  const lineNumbers = document.querySelector('.line-numbers');
  
  if (!codeEditor || !lineNumbers) return;
  
  const codeElement = codeEditor.querySelector('code');
  if (!codeElement) return;
  
  // 获取计算样式以确保一致性
  const computedStyle = window.getComputedStyle(codeElement);
  const lineHeight = parseInt(computedStyle.lineHeight) || 21;
  const fontSize = parseInt(computedStyle.fontSize) || 14;
  
  // 获取代码内容
  const lines = codeElement.textContent.split('\n');
  const lineCount = lines.length;
  
  if (lineCount === 0) return;
  
  // 重新计算每个行号的位置，VSCode风格
  const lineNumberElements = lineNumbers.querySelectorAll('.line-number');
  
  lineNumberElements.forEach((lineNumber, index) => {
    const lineIndex = index + 1;
    const topPosition = (lineIndex - 1) * lineHeight + 10; // 10px是code元素的padding-top
    
    // VSCode风格的精确定位
    lineNumber.style.position = 'absolute';
    lineNumber.style.top = topPosition + 'px';
    lineNumber.style.left = '0';
    lineNumber.style.right = '0';
    lineNumber.style.height = lineHeight + 'px';
    lineNumber.style.lineHeight = lineHeight + 'px';
    lineNumber.style.fontSize = fontSize + 'px';
    
    // 确保行号内容正确
    lineNumber.textContent = lineIndex;
    lineNumber.setAttribute('data-line', lineIndex);
  });
  
  // 更新行号容器高度
  const totalHeight = lineCount * lineHeight + 20; // 20px是编辑器的上下padding总和
  lineNumbers.style.height = totalHeight + 'px';
  
  // 同步滚动位置
  syncLineNumbersScroll();
  
  console.log('VSCode风格行号对齐完成:', {
    lineCount,
    lineHeight,
    fontSize,
    totalHeight
  });
}

// 更新标题栏文件名
function updateTitleBarFileName(fileName) {
  const fileNameElement = document.querySelector('.file-name');
  if (fileNameElement) {
    if (fileName) {
      fileNameElement.textContent = ` - ${fileName}`;
    } else {
      fileNameElement.textContent = '';
    }
  }
}

// 终端功能
function toggleTerminal() {
  const terminalPanel = document.getElementById('terminal-panel');
  if (terminalPanel) {
    if (terminalPanel.classList.contains('hidden') || terminalPanel.style.display === 'none') {
      // 显示终端
      terminalPanel.classList.remove('hidden');
      terminalPanel.style.display = 'flex';
    } else {
      // 隐藏终端
      terminalPanel.classList.add('hidden');
      terminalPanel.style.display = 'none';
    }
  }
}

function minimizeTerminal() {
  const terminalPanel = document.getElementById('terminal-panel');
  if (terminalPanel) {
    terminalPanel.classList.toggle('minimized');
  }
}

function closeTerminal() {
  console.log('closeTerminal 被调用');
  const terminalPanel = document.getElementById('terminal-panel');
  console.log('找到终端面板:', terminalPanel);
  
  if (terminalPanel) {
    console.log('关闭前终端面板状态:');
    console.log('- display:', terminalPanel.style.display);
    console.log('- 类名:', terminalPanel.className);
    
    // 由于有内联样式，需要直接设置display为none来隐藏终端
    terminalPanel.style.display = 'none';
    terminalPanel.classList.add('hidden');
    
    console.log('关闭后终端面板状态:');
    console.log('- display:', terminalPanel.style.display);
    console.log('- 类名:', terminalPanel.className);
  } else {
    console.error('未找到终端面板元素！');
  }
}

// 终端实例管理
let terminalInstances = [];
let currentTerminalIndex = 0;

function newTerminal() {
  // 创建新的终端实例
  const terminalId = `terminal-${Date.now()}`;
  const terminalInstance = {
    id: terminalId,
    workingDir: terminalWorkingDir, // 继承当前工作目录
    output: [],
    isActive: false
  };
  
  terminalInstances.push(terminalInstance);
  
  // 切换到新终端
  switchToTerminal(terminalInstances.length - 1);
  
  // 清空终端输出并显示欢迎信息
  clearTerminal();
  
  // 显示新终端信息
  const terminalOutput = document.querySelector('.terminal-output');
  if (terminalOutput) {
    const welcomeLine = document.createElement('div');
    welcomeLine.className = 'terminal-line welcome-line';
    welcomeLine.textContent = `欢迎使用 Blue Code 终端 (${terminalId})`;
    terminalOutput.appendChild(welcomeLine);
    
    // 显示当前目录
    if (terminalWorkingDir) {
      const dirLine = document.createElement('div');
      dirLine.className = 'terminal-line dir-line';
      dirLine.textContent = `当前目录: ${terminalWorkingDir}`;
      terminalOutput.appendChild(dirLine);
    }
    
    // 显示提示信息
    const helpLine = document.createElement('div');
    helpLine.className = 'terminal-line help-line';
    helpLine.textContent = '输入 "help" 查看可用命令，或直接输入系统命令';
    terminalOutput.appendChild(helpLine);
  }
  
  // 更新终端提示符
  updateTerminalPrompt();
  
  console.log(`创建新终端: ${terminalId}`);
}

function switchToTerminal(index) {
  if (index >= 0 && index < terminalInstances.length) {
    // 保存当前终端状态
    if (currentTerminalIndex < terminalInstances.length) {
      terminalInstances[currentTerminalIndex].workingDir = terminalWorkingDir;
      terminalInstances[currentTerminalIndex].isActive = false;
    }
    
    // 切换到新终端
    currentTerminalIndex = index;
    const terminal = terminalInstances[currentTerminalIndex];
    terminalWorkingDir = terminal.workingDir;
    terminal.isActive = true;
    
    // 更新提示符
    updateTerminalPrompt();
    
    console.log(`切换到终端: ${terminal.id}`);
  }
}

// 初始化终端功能
async function initTerminal() {
  console.log('初始化终端...');
  
  // 确保终端面板默认可见
  const terminalPanel = document.getElementById('terminal-panel');
  if (terminalPanel) {
    terminalPanel.classList.remove('hidden');
    terminalPanel.classList.remove('minimized');
    if (!terminalPanel.style.height || terminalPanel.style.height === '0px') {
      terminalPanel.style.height = '200px';
    }
  }
  
  // 确保终端容器有正确的初始高度
  const terminalContainer = document.getElementById('terminal-container');
  if (terminalContainer) {
    // 如果没有设置高度或高度为0，设置为默认高度
    if (!terminalContainer.style.height || terminalContainer.style.height === '0px') {
      terminalContainer.style.height = '200px';
    }
    console.log('终端容器初始高度:', terminalContainer.style.height);
  }
  
  const terminalControls = document.querySelectorAll('.terminal-controls i');
  terminalControls.forEach(control => {
    control.addEventListener('click', () => {
      const title = control.getAttribute('title');
      switch (title) {
        case '新建终端':
          newTerminal();
          break;
        case '关闭终端':
          closeTerminal();
          break;
      }
    });
  });

  // 创建第一个终端实例
  const firstTerminal = {
    id: 'terminal-main',
    workingDir: '',
    output: [],
    isActive: true
  };
  terminalInstances.push(firstTerminal);
  currentTerminalIndex = 0;
  
  // 初始化终端输出
  await initTerminalOutput();

  // 终端输入处理
  const terminalInput = document.querySelector('.terminal-input');
  if (terminalInput) {
    terminalInput.addEventListener('keydown', async (e) => {
      if (e.key === 'Enter') {
        const command = terminalInput.value.trim();
        if (command) {
          // 特殊命令处理
          if (command === 'help') {
            showHelp();
          } else if (command === 'clear' || command === 'cls') {
            clearTerminal();
          } else {
            // 执行系统命令
            await executeCommand(command);
          }
        }
        terminalInput.value = '';
      }
    });
  }

  // 初始化终端拖拽调整
  initTerminalResizer();
  
  // 初始化图片预览容器高度
  setTimeout(() => {
    updateImagePreviewHeight();
  }, 100);
}

// 初始化终端拖拽调整
function initTerminalResizer() {
  const terminalResizer = document.querySelector('.terminal-resizer');
  const terminalContainer = document.getElementById('terminal-container');
  
  if (!terminalResizer || !terminalContainer) return;

  let isResizing = false;
  let startY = 0;
  let startHeight = 0;

  terminalResizer.addEventListener('mousedown', (e) => {
    isResizing = true;
    startY = e.clientY;
    startHeight = terminalContainer.offsetHeight;
    
    // 添加调整中的样式
    document.body.style.cursor = 'row-resize';
    document.body.style.userSelect = 'none';
    terminalResizer.classList.add('resizing');
    
    document.addEventListener('mousemove', handleMouseMove);
    document.addEventListener('mouseup', handleMouseUp);
    
    e.preventDefault();
  });

  function handleMouseMove(e) {
    if (!isResizing) return;
    
    // 向下拖动减少高度，向上拖动增加高度
    const deltaY = e.clientY - startY;
    const newHeight = startHeight - deltaY;
    
    // 限制最小和最大高度
    const minHeight = 150; // 最小高度，确保输入框不被压下去
    const maxHeight = Math.min(window.innerHeight * 0.8, window.innerHeight - 200); // 最大高度，留出足够空间给编辑器
    
    // 应用新的高度，确保在合理范围内
    if (newHeight >= minHeight && newHeight <= maxHeight) {
      terminalContainer.style.height = newHeight + 'px';
    } else if (newHeight < minHeight) {
      terminalContainer.style.height = minHeight + 'px';
    } else if (newHeight > maxHeight) {
      terminalContainer.style.height = maxHeight + 'px';
    }
    
    // 实时更新图片预览容器高度
    updateImagePreviewHeight();
    
    // 强制重新计算布局
    terminalContainer.offsetHeight; // 触发重排
  }

  function handleMouseUp() {
    isResizing = false;
    
    // 恢复样式
    document.body.style.cursor = '';
    document.body.style.userSelect = '';
    terminalResizer.classList.remove('resizing');
    
    // 更新图片预览容器高度
    updateImagePreviewHeight();
    
    document.removeEventListener('mousemove', handleMouseMove);
    document.removeEventListener('mouseup', handleMouseUp);
  }
}

// 初始化侧边栏拖拽调整
function initSidebarResizer() {
  const sidebarResizer = document.querySelector('.sidebar-resizer');
  const sidebar = document.querySelector('.sidebar');
  
  if (!sidebarResizer || !sidebar) return;

  let isResizing = false;
  let startX = 0;
  let startWidth = 0;

  sidebarResizer.addEventListener('mousedown', (e) => {
    isResizing = true;
    startX = e.clientX;
    startWidth = sidebar.offsetWidth;
    
    // 添加调整中的样式
    document.body.style.cursor = 'col-resize';
    document.body.style.userSelect = 'none';
    sidebarResizer.classList.add('resizing');
    
    document.addEventListener('mousemove', handleMouseMove);
    document.addEventListener('mouseup', handleMouseUp);
    
    e.preventDefault();
  });

  function handleMouseMove(e) {
    if (!isResizing) return;
    
    const deltaX = e.clientX - startX;
    const newWidth = startWidth + deltaX;
    
    // 限制最小和最大宽度
    const minWidth = 250; // 与CSS中的min-width保持一致
    const maxWidth = 500;
    
    if (newWidth >= minWidth && newWidth <= maxWidth) {
      sidebar.style.width = newWidth + 'px';
    }
  }

  function handleMouseUp() {
    isResizing = false;
    
    // 恢复样式
    document.body.style.cursor = '';
    document.body.style.userSelect = '';
    sidebarResizer.classList.remove('resizing');
    
    document.removeEventListener('mousemove', handleMouseMove);
    document.removeEventListener('mouseup', handleMouseUp);
  }
}

// 初始化右键菜单
function initContextMenu() {
  const tabContextMenu = document.getElementById('tab-context-menu');
  const fileContextMenu = document.getElementById('file-context-menu');
  const editorContextMenu = document.getElementById('editor-context-menu');
  let currentTabPath = null;
  let currentTabName = null;
  let currentFilePath = null;
  let currentFileName = null;

  // 为所有标签和文件添加右键事件
  document.addEventListener('contextmenu', (e) => {
    const tab = e.target.closest('.tab');
    if (tab) {
      e.preventDefault();
      e.stopPropagation();
      currentTabPath = tab.getAttribute('data-path');
      currentTabName = tab.querySelector('span').textContent;
      currentFilePath = null;
      currentFileName = null;
      showContextMenu(e.clientX, e.clientY, tabContextMenu);
      return;
    }
    
    // 文件资源管理器右键菜单事件
    const fileItem = e.target.closest('.file-item');
    const folderItem = e.target.closest('.folder-item');
    if (fileItem || folderItem) {
      e.preventDefault();
      e.stopPropagation();
      currentTabPath = null;
      currentTabName = null;
      currentFilePath = fileItem ? fileItem.getAttribute('data-path') : folderItem.getAttribute('data-path');
      currentFileName = fileItem ? fileItem.querySelector('span').textContent : folderItem.querySelector('span').textContent;
      showContextMenu(e.clientX, e.clientY, fileContextMenu);
      return;
    }
    
    // 编辑器右键菜单事件
    const editor = e.target.closest('#code-editor') || e.target.closest('.editor');
    if (editor) {
      e.preventDefault();
      e.stopPropagation();
      currentTabPath = null;
      currentTabName = null;
      currentFilePath = null;
      currentFileName = null;
      showContextMenu(e.clientX, e.clientY, editorContextMenu);
      return;
    }
  });

  // 点击其他地方隐藏菜单
  document.addEventListener('click', (e) => {
    // 如果点击的是右键菜单或其子元素，不隐藏菜单
    if (e.target.closest('.context-menu')) {
      return;
    }
    hideAllContextMenus();
    closeAllMenus();
  });

  // 按ESC键隐藏菜单
  document.addEventListener('keydown', (e) => {
    if (e.key === 'Escape') {
      hideAllContextMenus();
      closeAllMenus();
    }
  });

  // 处理标签页菜单项点击
  tabContextMenu.addEventListener('click', (e) => {
    e.stopPropagation();
    const menuItem = e.target.closest('.context-menu-item');
    if (menuItem && currentTabPath) {
      const action = menuItem.getAttribute('data-action');
      handleContextMenuAction(action, currentTabPath, currentTabName);
    }
  });

  // 处理文件菜单项点击
  fileContextMenu.addEventListener('click', (e) => {
    e.stopPropagation();
    const menuItem = e.target.closest('.context-menu-item');
    if (menuItem && currentFilePath) {
      const action = menuItem.getAttribute('data-action');
      handleFileContextMenuAction(action, currentFilePath, currentFileName);
    }
  });

  // 处理编辑器菜单项点击
  editorContextMenu.addEventListener('click', (e) => {
    e.stopPropagation();
    const menuItem = e.target.closest('.context-menu-item');
    if (menuItem) {
      const action = menuItem.getAttribute('data-action');
      handleEditorContextMenuAction(action);
    }
  });

  function showContextMenu(x, y, menu) {
    // 先关闭所有已展开的菜单（包括菜单栏菜单）
    hideAllContextMenus();
    closeAllMenus();
    
    menu.style.left = x + 'px';
    menu.style.top = y + 'px';
    menu.classList.add('show');
    
    // 确保菜单不超出窗口边界
    const rect = menu.getBoundingClientRect();
    if (rect.right > window.innerWidth) {
      menu.style.left = (x - rect.width) + 'px';
    }
    if (rect.bottom > window.innerHeight) {
      menu.style.top = (y - rect.height) + 'px';
    }
  }



  function hideContextMenu(menu) {
    menu.classList.remove('show');
  }

  async function handleContextMenuAction(action, path, name) {
    hideAllContextMenus();
    
    switch (action) {
      case 'close':
        await fileSystem.closeTab(path);
        break;
      case 'close-others':
        await closeOtherTabs(path);
        break;
      case 'close-all':
        await closeAllTabs();
        break;
      case 'copy-path':
        copyToClipboard(path);
        break;
      case 'copy-name':
        copyToClipboard(name);
        break;
      case 'reveal-in-explorer':
        revealInExplorer(path);
        break;
      case 'open-external':
        openWithExternalApp(path);
        break;
      case 'pin':
        pinTab(path);
        break;
      case 'duplicate':
        duplicateTab(path, name);
        break;
    }
  }

  function handleFileContextMenuAction(action, path, name) {
    hideAllContextMenus();
    
    switch (action) {
      case 'open':
        fileSystem.openFile(path, name);
        break;
      case 'open-new-tab':
        fileSystem.openFile(path, name);
        break;
      case 'copy-path':
        copyToClipboard(path);
        break;
      case 'copy-name':
        copyToClipboard(name);
        break;
      case 'reveal-in-explorer':
        revealInExplorer(path);
        break;
      case 'open-external':
        openWithExternalApp(path);
        break;
      case 'rename':
        // TODO: 实现重命名功能
        console.log('重命名文件:', path);
        break;
      case 'delete':
        // TODO: 实现删除功能
        console.log('删除文件:', path);
        break;
      case 'properties':
        // TODO: 实现属性查看功能
        console.log('查看文件属性:', path);
        break;
    }
  }

  function handleEditorContextMenuAction(action) {
    hideAllContextMenus();
    let codeEditor = document.getElementById('code-editor');
    
    switch (action) {
      case 'undo':
        document.execCommand('undo');
        break;
      case 'redo':
        document.execCommand('redo');
        break;
      case 'cut':
        document.execCommand('cut');
        break;
      case 'copy':
        document.execCommand('copy');
        break;
      case 'paste':
        document.execCommand('paste');
        break;
      case 'select-all':
        document.execCommand('selectAll');
        break;
      case 'find':
        showFindDialog();
        break;
      case 'replace':
        showReplaceDialog();
        break;
      case 'format':
        // TODO: 实现代码格式化功能
        console.log('格式化代码');
        break;
      case 'comment':
        // TODO: 实现注释/取消注释功能
        console.log('注释/取消注释');
        break;
    }
  }
}

// 关闭其他标签页
async function closeOtherTabs(currentPath) {
  const tabs = document.querySelectorAll('.tab');
  for (const tab of tabs) {
    const path = tab.getAttribute('data-path');
    if (path !== currentPath) {
      await fileSystem.closeTab(path);
    }
  }
}

// 关闭所有标签页
async function closeAllTabs() {
  const tabs = document.querySelectorAll('.tab');
  for (const tab of tabs) {
    const path = tab.getAttribute('data-path');
    await fileSystem.closeTab(path);
  }
}

// 复制到剪贴板
async function copyToClipboard(text) {
  try {
    await navigator.clipboard.writeText(text);
    console.log('已复制到剪贴板:', text);
  } catch (error) {
    console.error('复制失败:', error);
    // 备用方案
    const textArea = document.createElement('textarea');
    textArea.value = text;
    document.body.appendChild(textArea);
    textArea.select();
    document.execCommand('copy');
    document.body.removeChild(textArea);
  }
}

// 在资源管理器中显示文件
let revealInExplorerInProgress = false;
async function revealInExplorer(path) {
  // 防止重复调用
  if (revealInExplorerInProgress) {
    console.log('revealInExplorer 正在执行中，跳过重复调用');
    return;
  }
  
  revealInExplorerInProgress = true;
  
  try {
    // 使用 Tauri 的 opener API 来在资源管理器中显示文件
    await window.__TAURI__.opener.revealItemInDir(path);
    console.log('已在资源管理器中显示:', path);
  } catch (error) {
    console.error('在资源管理器中显示文件失败:', error);
    
    // 备用方案：尝试使用 opener.openPath 打开文件所在目录
    try {
      // 获取文件所在目录
      const pathParts = path.split(/[\\/]/);
      const fileName = pathParts.pop();
      const directory = pathParts.join('/');
      
      await window.__TAURI__.opener.openPath(directory);
      console.log('使用备用方案打开目录:', directory);
    } catch (fallbackError) {
      console.error('备用方案也失败:', fallbackError);
    }
  } finally {
    // 延迟重置状态，防止快速连续点击
    setTimeout(() => {
      revealInExplorerInProgress = false;
    }, 500);
  }
}

// 使用系统默认程序打开文件
let openWithExternalAppInProgress = false;
async function openWithExternalApp(path) {
  // 防止重复调用
  if (openWithExternalAppInProgress) {
    console.log('openWithExternalApp 正在执行中，跳过重复调用');
    return;
  }
  
  openWithExternalAppInProgress = true;
  
  try {
    console.log('尝试打开文件:', path);
    
    // 方法1：使用 Rust 后端命令
    try {
      await window.__TAURI__.core.invoke('open_file_with_system', { path });
      console.log('已使用 Rust 后端打开:', path);
      return;
    } catch (error1) {
      console.log('Rust 后端方法失败:', error1);
    }
    
    // 方法2：使用 opener 插件
    if (window.__TAURI__ && window.__TAURI__.opener) {
      try {
        await window.__TAURI__.opener.openPath(path);
        console.log('已使用 opener 插件打开:', path);
        return;
      } catch (error2) {
        console.log('opener 插件失败:', error2);
      }
    }
    
    // 方法3：使用 shell 插件（如果可用）
    if (window.__TAURI__ && window.__TAURI__.shell) {
      try {
        await window.__TAURI__.shell.open(path);
        console.log('已使用 shell 插件打开:', path);
        return;
      } catch (error3) {
        console.log('shell 插件失败:', error3);
      }
    }
    
    // 方法4：使用 window.open（备用方案）
    try {
      const fileUrl = `file://${path.replace(/\\/g, '/')}`;
      window.open(fileUrl, '_blank');
      console.log('已使用 window.open 打开:', fileUrl);
      return;
    } catch (error4) {
      console.log('window.open 失败:', error4);
    }
    
    throw new Error('所有打开方法都失败了');
    
  } catch (error) {
    console.error('打开文件失败:', error);
    alert(`无法打开文件: ${path}\n错误: ${error.message}`);
  } finally {
    // 延迟重置状态，防止快速连续点击
    setTimeout(() => {
      openWithExternalAppInProgress = false;
    }, 500);
  }
}

// 固定标签页
function pinTab(path) {
  const tab = document.querySelector(`.tab[data-path="${path}"]`);
  if (tab) {
    tab.classList.toggle('pinned');
    console.log('标签页固定状态已切换:', path);
  }
}

// 复制标签页
function duplicateTab(path, name) {
  // 重新打开同一个文件，创建新的标签页
  fileSystem.openFile(path, name);
  console.log('已复制标签页:', path);
}

// 终端状态管理

// 更新终端提示符
function updateTerminalPrompt() {
  // 更新输入框前的提示符
  const inputPromptElement = document.querySelector('.terminal-input-line .terminal-prompt');
  if (inputPromptElement) {
    if (terminalWorkingDir) {
      // 显示当前目录路径 + >
      inputPromptElement.textContent = `${terminalWorkingDir}> `;
    } else {
      // 默认显示 $
      inputPromptElement.textContent = '$ ';
    }
  }
  
  // 同时更新输出区域的提示符（如果存在）
  const outputPromptElement = document.getElementById('terminal-prompt');
  if (outputPromptElement) {
    if (terminalWorkingDir) {
      outputPromptElement.textContent = `${terminalWorkingDir}> `;
    } else {
      outputPromptElement.textContent = '$ ';
    }
  }
}

// 执行终端命令
async function executeCommand(command) {
  const terminalOutput = document.querySelector('.terminal-output');
  if (!terminalOutput) return;

  // 显示命令
  const commandLine = document.createElement('div');
  commandLine.className = 'terminal-line command-line';
  // 使用当前工作目录的提示符
  const currentPrompt = terminalWorkingDir ? `${terminalWorkingDir}>` : '$';
  commandLine.innerHTML = `<span class="prompt">${currentPrompt}</span> <span class="command">${command}</span>`;
  terminalOutput.appendChild(commandLine);

  try {
    // 解析命令和参数
    const parts = command.trim().split(/\s+/);
    const cmd = parts[0];
    const args = parts.slice(1);

    // 处理内置命令
    if (cmd === 'help') {
      showHelp();
      return;
    } else if (cmd === 'clear' || cmd === 'cls') {
      clearTerminal();
      return;
    } else if (cmd === 'echo') {
      const text = parts.slice(1).join(' ');
      const outputLine = document.createElement('div');
      outputLine.className = 'terminal-line output-line';
      outputLine.textContent = text;
      terminalOutput.appendChild(outputLine);
    } else {
      // 执行系统命令（包括 cd、pwd 等）
      const result = await window.__TAURI__.core.invoke('execute_command', {
        command: cmd,
        args: args,
        workingDir: terminalWorkingDir || undefined
      });

      // 处理工作目录变化
      if (result.new_working_dir) {
        terminalWorkingDir = result.new_working_dir;
        console.log('工作目录已更改为:', terminalWorkingDir);
        
        // 更新终端提示符
        updateTerminalPrompt();
      }

      // 显示输出
      if (result.success) {
        if (result.output.trim()) {
          const outputLine = document.createElement('div');
          outputLine.className = 'terminal-line output-line';
          outputLine.textContent = result.output;
          terminalOutput.appendChild(outputLine);
        }
      } else {
        // 显示错误
        const errorLine = document.createElement('div');
        errorLine.className = 'terminal-line error-line';
        errorLine.textContent = result.error || '命令执行失败';
        terminalOutput.appendChild(errorLine);
      }

      // 显示退出码（如果不是0，且不是成功的情况）
      if (result.exit_code !== 0 && !result.success) {
        const exitLine = document.createElement('div');
        exitLine.className = 'terminal-line exit-line';
        exitLine.textContent = `[退出码: ${result.exit_code}]`;
        terminalOutput.appendChild(exitLine);
      }
    }

  } catch (error) {
    // 显示错误
    const errorLine = document.createElement('div');
    errorLine.className = 'terminal-line error-line';
    errorLine.textContent = `错误: ${error}`;
    terminalOutput.appendChild(errorLine);
  }

  // 滚动到底部
  terminalOutput.scrollTop = terminalOutput.scrollHeight;
  // 确保输入框可见
  ensureTerminalInputVisible();
}

// 初始化终端输出
async function initTerminalOutput() {
  const terminalOutput = document.querySelector('.terminal-output');
  if (!terminalOutput) return;

  try {
    // 清空终端输出
    terminalOutput.innerHTML = '';
    
    // 显示欢迎信息（与newTerminal保持一致）
    const welcomeLine = document.createElement('div');
    welcomeLine.className = 'terminal-line welcome-line';
    welcomeLine.textContent = '欢迎使用 Blue Code 终端 (terminal-main)';
    terminalOutput.appendChild(welcomeLine);
    
    // 设置初始工作目录
    try {
      terminalWorkingDir = await window.__TAURI__.core.invoke('get_current_directory');
      const dirLine = document.createElement('div');
      dirLine.className = 'terminal-line dir-line';
      dirLine.textContent = `当前目录: ${terminalWorkingDir}`;
      terminalOutput.appendChild(dirLine);
      
      // 更新终端提示符
      updateTerminalPrompt();
    } catch (error) {
      console.log('获取当前目录失败:', error);
      terminalWorkingDir = '';
      updateTerminalPrompt();
    }
    
    // 显示提示信息（与newTerminal保持一致）
    const helpLine = document.createElement('div');
    helpLine.className = 'terminal-line help-line';
    helpLine.textContent = '输入 "help" 查看可用命令，或直接输入系统命令';
    terminalOutput.appendChild(helpLine);
    
  } catch (error) {
    console.error('初始化终端输出失败:', error);
  }
}

// 显示帮助信息
function showHelp() {
  const terminalOutput = document.querySelector('.terminal-output');
  if (!terminalOutput) return;

  const helpText = `
可用命令:
  help          - 显示此帮助信息
  clear/cls     - 清空终端
  pwd           - 显示当前目录
  echo <文本>   - 显示文本
  dir           - 列出目录内容（Windows 命令）
  cd <目录>     - 切换目录（支持相对路径和绝对路径）
  cd ..         - 返回上级目录
  ver           - 显示系统版本
  type <文件>   - 显示文件内容
  copy <源> <目标> - 复制文件
  move <源> <目标> - 移动文件
  del <文件>    - 删除文件
  mkdir <目录>  - 创建目录
  rmdir <目录>  - 删除目录
  ping <地址>   - 网络连通性测试
  ipconfig      - 显示网络配置
  date          - 显示当前日期
  time          - 显示当前时间
  其他命令      - 执行任何 Windows 命令
  `;

  const helpLine = document.createElement('div');
  helpLine.className = 'terminal-line help-content';
  helpLine.textContent = helpText;
  terminalOutput.appendChild(helpLine);
  
  // 滚动到底部
  terminalOutput.scrollTop = terminalOutput.scrollHeight;
  // 确保输入框可见
  ensureTerminalInputVisible();
}

// 确保终端输入框始终可见
function ensureTerminalInputVisible() {
  const terminalPanel = document.querySelector('.terminal-panel');
  const terminalInput = document.querySelector('.terminal-input');
  
  if (terminalPanel && terminalInput) {
    // 确保终端面板可见
    if (terminalPanel.style.display === 'none') {
      terminalPanel.style.display = 'flex';
    }
    
    // 确保输入框在视口内
    const inputRect = terminalInput.getBoundingClientRect();
    const panelRect = terminalPanel.getBoundingClientRect();
    
    if (inputRect.bottom > panelRect.bottom) {
      // 如果输入框超出面板底部，滚动到输入框位置
      terminalInput.scrollIntoView({ behavior: 'smooth', block: 'end' });
    }
    
    // 聚焦到输入框
    terminalInput.focus();
  }
}

// 清空终端
function clearTerminal() {
  const terminalOutput = document.querySelector('.terminal-output');
  if (terminalOutput) {
    terminalOutput.innerHTML = '';
  }
}

// 检测是否为开发模式的函数
function isDevelopmentMode() {
  if (typeof window === 'undefined' || !window.__TAURI__) {
    return false;
  }
  
  // 检查URL是否包含开发服务器地址
  const isDevServer = window.location.href.includes('localhost') || 
                     window.location.href.includes('127.0.0.1') ||
                     window.location.href.includes('dev-server');
  
  // 检查是否有热重载相关的特征
  const hasDevFeatures = window.location.href.includes('__webpack_hmr') ||
                        window.location.href.includes('hot-reload');
  
  return isDevServer || hasDevFeatures;
}

// 在发布版本中禁用console输出
if (typeof window !== 'undefined' && window.__TAURI__) {
  const isProduction = !isDevelopmentMode();
  if (isProduction) {
    // 重写console方法以禁用输出
    console.log = () => {};
    console.error = () => {};
    console.warn = () => {};
    console.info = () => {};
    console.debug = () => {};
  }
}

// 禁用浏览器默认右键菜单，防止被识别为webview
document.addEventListener('contextmenu', (e) => {
  // 检查是否点击在允许自定义右键菜单的区域
  const target = e.target;
  const isEditor = target.closest('#code-editor') || 
                   target.closest('.editor') || 
                   target.closest('.terminal-output') ||
                   target.closest('.file-explorer') ||
                   target.closest('.tab') ||
                   target.closest('.tab-bar');
  
  // 如果在允许的区域，只阻止默认菜单，不阻止事件传播
  if (isEditor) {
    e.preventDefault();
    e.stopPropagation();
    return;
  }
  
  // 在其他所有区域禁用默认右键菜单
  e.preventDefault();
  e.stopPropagation();
  e.stopImmediatePropagation();
  return false;
}, false);

// 阻止所有右键相关事件
document.addEventListener('mousedown', (e) => {
  if (e.button === 2) { // 右键
    const target = e.target;
    const isEditor = target.closest('#code-editor') || 
                     target.closest('.editor') || 
                     target.closest('.terminal-output') ||
                     target.closest('.file-explorer') ||
                     target.closest('.tab') ||
                     target.closest('.tab-bar');
    
    if (!isEditor) {
      e.preventDefault();
      e.stopPropagation();
      e.stopImmediatePropagation();
      return false;
    }
  }
}, false);

// 键盘快捷键
document.addEventListener('keydown', async (e) => {
  // 只在发布版本中禁用开发者工具
  if (!isDevelopmentMode()) {
    // 禁用F12开发者工具
    if (e.key === 'F12') {
      e.preventDefault();
      e.stopPropagation();
      return false;
    }
    
    // 禁用Ctrl+Shift+I (Chrome开发者工具)
    if (e.ctrlKey && e.shiftKey && e.key === 'I') {
      e.preventDefault();
      e.stopPropagation();
      return false;
    }
    
    // 禁用Ctrl+Shift+J (Chrome控制台)
    if (e.ctrlKey && e.shiftKey && e.key === 'J') {
      e.preventDefault();
      e.stopPropagation();
      return false;
    }
    
    // 禁用Ctrl+U (查看源代码)
    if (e.ctrlKey && e.key === 'u') {
      e.preventDefault();
      e.stopPropagation();
      return false;
    }
  }
  
  // Ctrl+S 保存
  if (e.ctrlKey && e.key === 's') {
    e.preventDefault();
    if (fileSystem.currentFile) {
      let codeEditor = document.getElementById('code-editor');
      if (codeEditor) {
        const success = await fileSystem.writeFile(fileSystem.currentFile.path, codeEditor.value);
        if (success) {
          console.log('文件已保存');
        }
      }
    }
  }
  
  // Ctrl+N 新建文件
  if (e.ctrlKey && e.key === 'n') {
    e.preventDefault();
    console.log('新建文件');
  }
  
  // Ctrl+W 关闭标签
  if (e.ctrlKey && e.key === 'w') {
    e.preventDefault();
    if (fileSystem.currentFile) {
      await fileSystem.closeTab(fileSystem.currentFile.path);
    }
  }
  
  // Ctrl+O 打开文件
  if (e.ctrlKey && e.key === 'o') {
    e.preventDefault();
    console.log('打开文件');
  }
  
  // Ctrl+` 切换终端
  if (e.ctrlKey && e.key === '`') {
    e.preventDefault();
    toggleTerminal();
  }
  
  // Ctrl+Shift+` 新建终端
  if (e.ctrlKey && e.shiftKey && e.key === '`') {
    e.preventDefault();
    createNewTerminal();
  }
});

// 真实文件系统管理
class FileSystem {
  constructor() {
    this.currentDirectory = '';
    this.fileTree = new Map();
    this.openFiles = new Map();
    this.currentFile = null;
  }

  // 初始化文件系统
  async initialize() {
    try {
      this.currentDirectory = await invoke('get_current_directory');
      const items = await this.loadDirectory(this.currentDirectory);
      this.updateFileExplorer(this.currentDirectory, items);
      console.log('文件系统已初始化，当前目录:', this.currentDirectory);
    } catch (error) {
      console.error('初始化文件系统失败:', error);
    }
  }

  // 加载目录内容
  async loadDirectory(path) {
    try {
      const items = await invoke('read_directory', { path });
      this.fileTree.set(path, items);
      return items;
    } catch (error) {
      console.error('加载目录失败:', error);
      return [];
    }
  }

  // 读取文件内容
  async readFile(path) {
    try {
      const fileContent = await invoke('read_file', { path });
      this.openFiles.set(path, fileContent.content);
      console.log('文件读取成功，是否为二进制:', fileContent.is_binary);
      return fileContent.content;
    } catch (error) {
      console.error('读取文件失败:', error);
      
      // 检查是否是文件过大的错误
      if (error.includes('文件过大')) {
        throw new Error(error);
      }
      
      return '';
    }
  }

  // 写入文件
  async writeFile(path, content) {
    try {
      await invoke('write_file', { path, content });
      this.openFiles.set(path, content);
      console.log('文件已保存:', path);
      return true;
    } catch (error) {
      console.error('写入文件失败:', error);
      return false;
    }
  }

  // 更新文件资源管理器
  updateFileExplorer(path, items) {
    const fileExplorer = document.querySelector('.file-explorer');
    if (!fileExplorer) return;

    fileExplorer.innerHTML = '';
    
    // 添加返回上级目录选项
    if (path !== this.currentDirectory) {
      const backItem = document.createElement('div');
      backItem.className = 'file-item back-item';
      backItem.innerHTML = `
        <i class="fas fa-level-up-alt"></i>
        <span>..</span>
      `;
      backItem.addEventListener('click', () => {
        const parentPath = path.split('\\').slice(0, -1).join('\\');
        this.loadDirectory(parentPath);
      });
      fileExplorer.appendChild(backItem);
    }

    // 添加文件和文件夹
    items.forEach(item => {
      const itemElement = document.createElement('div');
      itemElement.className = item.is_directory ? 'folder-item' : 'file-item';
      itemElement.setAttribute('data-path', item.path);
      
      const icon = item.is_directory ? 'fa-folder' : this.getFileIcon(item.extension);
      
      itemElement.innerHTML = `
        ${item.is_directory ? '<i class="fas fa-chevron-right"></i>' : ''}
        <i class="fas ${icon}"></i>
        <span>${item.name}</span>
        ${item.size ? `<span class="file-size">${this.formatFileSize(item.size)}</span>` : ''}
      `;
      
      itemElement.addEventListener('click', () => {
        if (item.is_directory) {
          this.toggleFolder(item.path, itemElement);
        } else {
          this.openFile(item.path, item.name);
        }
      });
      
      fileExplorer.appendChild(itemElement);
    });
  }

  // 切换文件夹展开/折叠状态
  async toggleFolder(path, folderElement) {
    const chevronIcon = folderElement.querySelector('i.fas.fa-chevron-right');
    const isExpanded = folderElement.classList.contains('expanded');
    
    if (isExpanded) {
      // 折叠文件夹
      folderElement.classList.remove('expanded');
      chevronIcon.style.transform = 'rotate(0deg)';
      
      // 移除子项
      const nextSibling = folderElement.nextElementSibling;
      while (nextSibling && nextSibling.classList.contains('folder-content')) {
        nextSibling.remove();
        break;
      }
    } else {
      // 展开文件夹
      folderElement.classList.add('expanded');
      chevronIcon.style.transform = 'rotate(90deg)';
      
      // 检查是否已经加载过内容
      const existingContent = folderElement.nextElementSibling;
      if (existingContent && existingContent.classList.contains('folder-content')) {
        existingContent.style.display = 'block';
        return;
      }
      
      // 加载文件夹内容
      try {
        const items = await this.loadDirectory(path);
        this.createFolderContent(folderElement, path, items);
      } catch (error) {
        console.error('加载文件夹内容失败:', error);
      }
    }
  }

  // 创建文件夹内容
  createFolderContent(folderElement, path, items) {
    const contentDiv = document.createElement('div');
    contentDiv.className = 'folder-content';
    contentDiv.style.marginLeft = '20px';
    
    items.forEach(item => {
      const itemElement = document.createElement('div');
      itemElement.className = item.is_directory ? 'folder-item' : 'file-item';
      itemElement.setAttribute('data-path', item.path);
      
      const icon = item.is_directory ? 'fa-folder' : this.getFileIcon(item.extension);
      
      itemElement.innerHTML = `
        ${item.is_directory ? '<i class="fas fa-chevron-right"></i>' : ''}
        <i class="fas ${icon}"></i>
        <span>${item.name}</span>
        ${item.size ? `<span class="file-size">${this.formatFileSize(item.size)}</span>` : ''}
      `;
      
      itemElement.addEventListener('click', (e) => {
        e.stopPropagation();
        if (item.is_directory) {
          this.toggleFolder(item.path, itemElement);
        } else {
          this.openFile(item.path, item.name);
        }
      });
      
      contentDiv.appendChild(itemElement);
    });
    
    // 插入到文件夹元素后面
    folderElement.parentNode.insertBefore(contentDiv, folderElement.nextSibling);
  }

  // 打开文件
  async openFile(path, name) {
    try {
      console.log('=== 开始打开文件 ===');
      console.log('文件路径:', path);
      console.log('文件名称:', name);
      
      // 检查是否为图片文件
      const isImageFile = this.isImageFile(name);
      if (isImageFile) {
        console.log('检测到图片文件，直接显示图片预览');
        // 隐藏文本编辑器，避免闪烁
        let codeEditor = document.getElementById('code-editor');
        if (codeEditor) {
          codeEditor.style.display = 'none';
        }
        // 隐藏行号
        const lineNumbers = document.querySelector('.line-numbers');
        if (lineNumbers) {
          lineNumbers.style.display = 'none';
        }
        
        await this.showImagePreview(path, name);
        return;
      }
      
      // 对于非图片文件，先清理当前显示的内容
      this.clearCurrentDisplay();
      
      // 首先尝试读取文件内容
      const content = await this.readFile(path);
      console.log('文件内容长度:', content.length);
      
      // 检查文件内容是否为可读文本
      const isText = this.isTextContent(content);
      console.log('是否为文本文件:', isText);
      
      if (!isText) {
        console.log('文件不是文本格式，显示不支持提示');
        // 显示不支持预览的提示
        this.showUnsupportedFileMessage(path, name, content);
        return;
      }
      
      this.currentFile = { path, name, content };
      
      // 将文件添加到缓存中
      this.openFiles.set(path, { path, name, content });
      
      // 使用showTextFile方法显示文件内容，确保应用代码高亮
      this.showTextFile(content);
      
      // 更新标签栏（标记为支持的文件）
      this.updateTabBar(path, name, false);
      
      // 更新标题栏
      updateTitleBarFileName(name);
      
      console.log('文件已打开:', path);
    } catch (error) {
      console.error('打开文件失败:', error);
      
      // 检查是否是文件过大的错误
      if (error.message && error.message.includes('文件过大')) {
        // 对于大文件，不缓存内容，直接显示提示
        this.showLargeFileMessage(path, name, error.message);
      } else {
        // 其他错误显示通用提示
        this.showUnsupportedFileMessage(path, name, null);
      }
    }
  }

  // 显示不支持预览文件的提示
  showUnsupportedFileMessage(path, name, content) {
    // 清理当前显示
    this.clearCurrentDisplay();
    
    // 分析文件内容类型
    const fileType = this.analyzeFileType(content, name);
    const message = this.getUnsupportedFileMessage(fileType, name);
    
    // 创建提示内容
    const fileSize = content && typeof content === 'string' ? this.formatFileSize(content.length) : '未知';
    const unsupportedContent = `/*
 * 文件预览不支持
 * =================
 * 
${message}
 * 
 * 文件路径: ${path}
 * 文件名称: ${name}
 * 文件类型: ${fileType}
 * 文件大小: ${fileSize}
 * 
 * 检测结果:
 * - 此文件包含二进制数据或不可读字符
 * - 无法在文本编辑器中正常显示
 * 
 * 建议操作:
 * - 使用合适的应用程序打开此文件
 * - 或者选择其他支持的文件类型
 */`;

    // 更新编辑器内容
    let codeEditor = document.getElementById('code-editor');
    if (codeEditor) {
      const codeElement = codeEditor.querySelector('code');
      if (codeElement) {
        codeElement.textContent = unsupportedContent;
        codeElement.className = 'language-plaintext';
        codeEditor.classList.add('unsupported-file'); // 添加CSS类
        codeEditor.contentEditable = 'false'; // 禁用编辑
        codeEditor.style.cursor = 'not-allowed'; // 显示禁止光标
        setTimeout(() => {
          updateLineNumbers();
          preciseAlignLineNumbers(); // 确保精确对齐
          ensureScrollSync();
        }, 0);
      }
    }
    
    // 更新标签栏（仍然创建标签，但显示特殊图标）
    this.updateTabBar(path, name, true);
    
    // 更新标题栏
    updateTitleBarFileName(name);
    
    // 缓存文件信息
    this.currentFile = { path, name, content };
    this.openFiles.set(path, { path, name, content, type: 'unsupported' });
    
    console.log('显示不支持文件提示:', path, '类型:', fileType);
  }

  // 显示大文件提示
  showLargeFileMessage(path, name, errorMessage) {
    // 清理当前显示
    this.clearCurrentDisplay();
    
    // 创建大文件提示内容
    const largeFileContent = `/*
 * 文件过大，无法在编辑器中打开
 * ==============================
 * 
 * 错误信息: ${errorMessage || '文件大小超过10MB限制'}
 * 
 * 文件路径: ${path}
 * 文件名称: ${name}
 * 
 * 原因分析:
 * - 此文件超过了编辑器的最大支持大小 (10MB)
 * - 大文件会导致编辑器性能问题
 * - 可能造成程序卡死或内存不足
 * 
 * 建议操作:
 * - 使用专业的文本编辑器（如 Notepad++、Sublime Text）
 * - 使用命令行工具查看文件（如 less、head、tail）
 * - 考虑分割大文件为多个小文件
 * - 或者使用专门的日志查看工具
 * 
 * 替代方案:
 * - 使用 "head -n 1000 filename" 查看文件前1000行
 * - 使用 "tail -n 1000 filename" 查看文件后1000行
 * - 使用 "grep" 搜索特定内容
 */`;

    // 更新编辑器内容
    let codeEditor = document.getElementById('code-editor');
    if (codeEditor) {
      const codeElement = codeEditor.querySelector('code');
      if (codeElement) {
        codeElement.textContent = largeFileContent;
        codeElement.className = 'language-plaintext';
        codeEditor.classList.add('large-file'); // 添加CSS类
        codeEditor.contentEditable = 'false'; // 禁用编辑
        codeEditor.style.cursor = 'not-allowed'; // 显示禁止光标
        setTimeout(() => {
          updateLineNumbers();
          preciseAlignLineNumbers(); // 确保精确对齐
          ensureScrollSync();
        }, 0);
      }
    }
    
    // 更新标签栏（显示特殊样式）
    this.updateTabBar(path, name, false, true);
    
    // 更新标题栏
    updateTitleBarFileName(name);
    
    // 缓存大文件信息（但不缓存内容）
    this.currentFile = { path, name, content: null };
    this.openFiles.set(path, { path, name, content: null, type: 'large' });
    
    console.log('显示大文件提示:', path, '错误:', errorMessage);
  }

  // 分析文件类型
  analyzeFileType(content, fileName) {
    if (!content || typeof content !== 'string') {
      console.log('分析文件类型：内容为空或不是字符串类型');
      return '未知';
    }
    
    const extension = fileName.split('.').pop()?.toLowerCase();
    console.log('分析文件类型，文件名:', fileName, '扩展名:', extension);
    
    // 检查文件头（魔数）来判断文件类型
    const header = content.substring(0, 16);
    console.log('文件头（十六进制）:', Array.from(header).map(c => c.charCodeAt(0).toString(16).padStart(2, '0')).join(' '));
    console.log('文件头（字符）:', header);
    
    // 可执行文件
    if (header.startsWith('MZ') || header.includes('PE')) {
      console.log('检测到Windows可执行文件');
      return 'Windows可执行文件';
    }
    if (header.startsWith('\x7fELF')) {
      console.log('检测到Linux可执行文件');
      return 'Linux可执行文件';
    }
    if (header.startsWith('\xfe\xed\xfa')) {
      console.log('检测到macOS可执行文件');
      return 'macOS可执行文件';
    }
    
    // 压缩文件
    if (header.startsWith('PK')) {
      console.log('检测到ZIP压缩文件');
      return 'ZIP压缩文件';
    }
    if (header.startsWith('Rar!')) {
      console.log('检测到RAR压缩文件');
      return 'RAR压缩文件';
    }
    if (header.startsWith('7z')) {
      console.log('检测到7-Zip压缩文件');
      return '7-Zip压缩文件';
    }
    
    // 图片文件
    if (header.startsWith('\xff\xd8\xff')) {
      console.log('检测到JPEG图片');
      return 'JPEG图片';
    }
    if (header.startsWith('\x89PNG')) {
      console.log('检测到PNG图片');
      return 'PNG图片';
    }
    if (header.startsWith('GIF8')) {
      console.log('检测到GIF图片');
      return 'GIF图片';
    }
    if (header.startsWith('BM')) {
      console.log('检测到BMP图片');
      return 'BMP图片';
    }
    
    // 音频文件
    if (header.startsWith('ID3') || header.startsWith('\xff\xfb')) {
      console.log('检测到MP3音频');
      return 'MP3音频';
    }
    if (header.startsWith('RIFF') && header.includes('WAVE')) {
      console.log('检测到WAV音频');
      return 'WAV音频';
    }
    
    // 视频文件
    if (header.startsWith('RIFF') && header.includes('AVI')) {
      console.log('检测到AVI视频');
      return 'AVI视频';
    }
    if (header.startsWith('\x00\x00\x00\x20ftyp')) {
      console.log('检测到MP4视频');
      return 'MP4视频';
    }
    
    // 文档文件
    if (header.startsWith('%PDF')) {
      console.log('检测到PDF文档');
      return 'PDF文档';
    }
    if (header.startsWith('\xd0\xcf\x11\xe0')) {
      console.log('检测到Microsoft Office文档');
      return 'Microsoft Office文档';
    }
    
    // 根据扩展名推测
    if (extension) {
      const extensionMap = {
        'exe': '可执行文件',
        'dll': '动态链接库',
        'msi': '安装程序',
        'zip': '压缩文件',
        'rar': '压缩文件',
        '7z': '压缩文件',
        'png': '图片文件',
        'jpg': '图片文件',
        'jpeg': '图片文件',
        'gif': '图片文件',
        'mp3': '音频文件',
        'wav': '音频文件',
        'mp4': '视频文件',
        'avi': '视频文件',
        'pdf': 'PDF文档',
        'doc': 'Word文档',
        'xls': 'Excel文档',
        'ppt': 'PowerPoint文档'
      };
      
      const detectedType = extensionMap[extension] || '二进制文件';
      console.log('根据扩展名推测文件类型:', detectedType);
      return detectedType;
    }
    
    console.log('未识别文件类型，默认为二进制文件');
    return '二进制文件';
  }

  // 更新标签栏
  updateTabBar(path, name, isUnsupported = false, isLargeFile = false, isImageFile = false) {
    const tabBar = document.querySelector('.tab-bar');
    if (!tabBar) return;

    // 检查标签是否已存在（从tab-list容器中查找）
    const tabList = document.getElementById('tab-list');
    const existingTab = tabList ? Array.from(tabList.children).find(tab => 
      tab.getAttribute('data-path') === path
    ) : null;
    
    console.log('=== updateTabBar 调试信息 ===');
    console.log('文件路径:', path);
    console.log('文件名称:', name);
    console.log('tabList 存在:', !!tabList);
    console.log('现有标签数量:', tabList ? tabList.children.length : 0);
    console.log('已存在的标签:', existingTab);
    console.log('是否创建新标签:', !existingTab);

    if (!existingTab) {
      // 创建新标签
      const newTab = document.createElement('div');
      newTab.className = 'tab';
      newTab.setAttribute('data-path', path);
      console.log('创建标签，路径:', path, '名称:', name, '不支持:', isUnsupported, '大文件:', isLargeFile, '图片:', isImageFile);
      
      // 为不支持的文件添加特殊样式
      if (isUnsupported) {
        newTab.classList.add('unsupported-file');
      }
      
      // 为大文件添加特殊样式
      if (isLargeFile) {
        newTab.classList.add('large-file');
      }
      
      // 为图片文件添加特殊样式
      if (isImageFile) {
        newTab.classList.add('image-file');
      }
      
      newTab.innerHTML = `
        <span class="tab-name">${name}</span>
        <i class="fas fa-times tab-close-btn" data-path="${path}"></i>
      `;
      
      // 添加标签事件
      newTab.addEventListener('click', async (e) => {
        console.log('标签被点击:', path, '目标元素:', e.target);
        // 如果点击的是关闭按钮，不切换标签
        if (e.target.tagName === 'I' && e.target.classList.contains('fa-times')) {
          console.log('点击的是关闭按钮，不切换标签');
          return;
        }
        console.log('开始切换到标签:', path);
        await this.switchToTab(path);
      });
      

      
      // 直接为关闭按钮添加点击事件
      const closeBtn = newTab.querySelector('i.tab-close-btn');
      if (closeBtn) {
        closeBtn.onclick = async (e) => {
          e.stopPropagation();
          e.preventDefault();
          console.log('直接事件：关闭按钮被点击，路径:', path);
          await this.closeTab(path);
        };
      }
      
      // 将新标签添加到tab-list容器中，确保从左到右排列
      const tabList = document.getElementById('tab-list');
      if (tabList) {
        tabList.appendChild(newTab);
      } else {
        // 如果找不到tab-list，则添加到tabBar作为后备
        tabBar.appendChild(newTab);
      }
    }

    // 激活当前标签
    this.activateTab(path);
    
    // 如果是新标签，确保它可见
    if (!existingTab) {
      console.log('新标签页添加完成，准备滚动到可见位置:', path);
      
      // 使用更长的延迟确保DOM完全更新
      setTimeout(() => {
        // 尝试多种方式查找新标签
        let newTab = document.querySelector(`.tab[data-path="${path}"]`);
        
        if (!newTab) {
          // 尝试转义特殊字符
          const escapedPath = path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
          newTab = document.querySelector(`.tab[data-path="${escapedPath}"]`);
        }
        
        if (!newTab) {
          // 尝试模糊匹配（忽略路径分隔符差异）
          const normalizedPath = path.replace(/\\/g, '/');
          const allTabs = Array.from(document.querySelectorAll('.tab'));
          newTab = allTabs.find(tab => {
            const tabPath = tab.getAttribute('data-path')?.replace(/\\/g, '/');
            return tabPath === normalizedPath;
          });
        }
        
        if (newTab) {
          console.log('找到新标签页元素，开始滚动:', newTab);
          scrollToTab(newTab);
        } else {
          // 输出详细的调试信息
          const allTabs = Array.from(document.querySelectorAll('.tab')).map(tab => ({
            element: tab,
            dataPath: tab.getAttribute('data-path'),
            textContent: tab.querySelector('.tab-name')?.textContent || 'unknown'
          }));
          console.warn('未找到新标签页元素:', path);
          console.warn('当前所有标签页信息:', allTabs);
          console.warn('tabList 子元素数量:', document.getElementById('tab-list')?.children.length || 0);
          
          // 最后尝试通过tabList查找最后一个标签
          const tabList = document.getElementById('tab-list');
          if (tabList && tabList.lastElementChild) {
            console.log('使用最后一个标签页作为备选:', tabList.lastElementChild);
            scrollToTab(tabList.lastElementChild);
          }
        }
      }, 100); // 增加延迟时间到100ms
    }
    
    // 无论是否是新标签，都要更新滚动按钮状态
    setTimeout(() => {
      updateTabScrollButtons();
    }, 150);
    
    // 更新欢迎语句显示状态
    updateWelcomeMessage();
  }

  // 切换到指定标签
  async switchToTab(path) {
    const file = this.openFiles.get(path);
    let codeEditor = document.getElementById('code-editor');
    const tab = document.querySelector(`.tab[data-path="${path}"]`);
    const name = tab ? tab.querySelector('span').textContent : path.split(/[\\/]/).pop();
    
    // 检查标签类型
    const isUnsupportedFile = tab && tab.classList.contains('unsupported-file');
    const isLargeFile = tab && tab.classList.contains('large-file');
    const isImageFile = tab && tab.classList.contains('image-file');
    
    console.log('切换到标签:', path, '名称:', name, '图片文件:', isImageFile);
    
    // 如果是图片文件，直接显示图片预览，不经过文本编辑器
    if (isImageFile) {
      console.log('检测到图片文件标签，直接显示图片预览');
      // 隐藏文本编辑器，避免闪烁
      if (codeEditor) {
        codeEditor.style.display = 'none';
      }
      // 隐藏行号
      const lineNumbers = document.querySelector('.line-numbers');
      if (lineNumbers) {
        lineNumbers.style.display = 'none';
      }
      
              try {
          await this.showImagePreview(path, name);
          this.activateTab(path);
          // 动态调整图片预览容器大小
          updateImagePreviewHeight();
          console.log('图片预览显示成功');
        } catch (error) {
          console.error('显示图片预览失败:', error);
          // 如果图片显示失败，显示错误信息
          this.showImageError(path, name, error.message);
          this.activateTab(path);
        }
      return;
    }
    
    // 对于非图片文件，先清理当前显示的内容
    this.clearCurrentDisplay();
    
    if (file) {
      // 检查文件类型
      if (file.type === 'image') {
        // 如果是图片文件，显示图片预览
        console.log('从缓存中检测到图片文件，显示图片预览');
        // 隐藏文本编辑器，避免闪烁
        if (codeEditor) {
          codeEditor.style.display = 'none';
        }
        // 隐藏行号
        const lineNumbers = document.querySelector('.line-numbers');
        if (lineNumbers) {
          lineNumbers.style.display = 'none';
        }
        
        try {
          await this.showImagePreview(path, name);
          this.activateTab(path);
          // 动态调整图片预览容器大小
          updateImagePreviewHeight();
        } catch (error) {
          console.error('显示图片预览失败:', error);
          this.showImageError(path, name, error.message);
          this.activateTab(path);
        }
        return;
      }
      
      if (isLargeFile) {
        // 如果是大文件，直接显示大文件提示，不重新读取
        this.showLargeFileMessage(path, name, '文件过大，无法在编辑器中打开');
        return;
      }
      
      if (isUnsupportedFile) {
        // 如果是不支持的文件，直接显示不支持提示，不重新读取
        this.showUnsupportedFileMessage(path, name, file);
        return;
      }
      
      // 检查文件内容是否为可读文本
      const isText = this.isTextContent(file.content);
      console.log('切换到标签，文件是否为文本:', isText);
      
      if (!isText) {
        // 如果不是文本文件，显示不支持预览的提示
        this.showUnsupportedFileMessage(path, name, file.content);
        return;
      }
      
      // 设置当前文件信息
      this.currentFile = { path, name, content: file.content };
      
      // 显示文本文件
      this.showTextFile(file.content);
      
      this.activateTab(path);
      
      // 确保激活的标签可见
      setTimeout(() => {
        const activeTab = document.querySelector(`.tab[data-path="${path}"]`);
        if (activeTab) {
          this.scrollToActiveTab(activeTab);
        }
      }, 0);
    } else {
      // 如果文件不在缓存中，重新读取文件
      console.log('文件不在缓存中，重新读取文件:', path);
      try {
        const content = await this.readFile(path);
        const isText = this.isTextContent(content);
        
        if (isText) {
          // 如果是文本文件，显示内容
          this.currentFile = { path, name, content };
          this.openFiles.set(path, { path, name, content });
          this.showTextFile(content);
          this.updateTabBar(path, name, false);
          updateTitleBarFileName(name);
        } else {
          // 如果不是文本文件，显示不支持提示
          this.showUnsupportedFileMessage(path, name, content);
        }
        this.activateTab(path);
      } catch (error) {
        console.error('重新读取文件失败:', error);
        // 显示错误提示
        this.showUnsupportedFileMessage(path, name, null);
        this.activateTab(path);
      }
    }
  }

  // 清理当前显示的内容
  clearCurrentDisplay() {
    let codeEditor = document.getElementById('code-editor');
    const codeContent = document.querySelector('.code-content');
    
    console.log('清理当前显示，编辑器元素:', codeEditor);
    console.log('代码内容容器:', codeContent);
    
    // 清除图片预览或其他内容（从编辑器区域）
    const editorArea = document.querySelector('.editor-area');
    if (editorArea) {
      const imageWrapper = editorArea.querySelector('.image-preview-wrapper');
      if (imageWrapper) {
        console.log('移除图片预览容器');
        imageWrapper.remove();
      }
    }
    
    if (codeEditor) {
      // 恢复文本编辑器显示
      codeEditor.style.display = 'block';
      codeEditor.contentEditable = 'true'; // 恢复编辑功能
      codeEditor.style.cursor = 'text'; // 恢复文本光标
      codeEditor.classList.remove('unsupported-file', 'large-file'); // 移除特殊样式类
      const codeElement = codeEditor.querySelector('code');
      if (codeElement) {
        codeElement.textContent = ''; // 清空编辑器内容
        codeElement.className = 'language-plaintext';
      }
      console.log('恢复文本编辑器显示');
    } else {
      console.error('清理时找不到文本编辑器');
    }
    
    // 恢复行号显示
    const lineNumbers = document.querySelector('.line-numbers');
    if (lineNumbers) {
      lineNumbers.style.display = 'block';
    }
    
    // 重新初始化编辑器布局
    initializeEditorLayout();
    
    // 更新行号
    setTimeout(() => {
      updateLineNumbers();
      preciseAlignLineNumbers(); // 确保精确对齐
      ensureScrollSync();
      forceRecalculateEditorScroll();
      // 强制同步行号容器高度
      forceSyncLineNumbersHeight();
    }, 0);
  }

  // 显示文本文件
  showTextFile(content) {
    try {
      const codeEditor = document.getElementById('code-editor');
      let codeElement = codeEditor ? codeEditor.querySelector('code') : null;
      if (codeEditor && !codeElement) {
        codeElement = document.createElement('code');
        codeEditor.appendChild(codeElement);
      }
      if (!codeEditor || !codeElement) {
        console.warn('showTextFile: 找不到代码元素');
        return;
      }
      
      // 清理编辑器状态
      codeElement.textContent = content || '';
      codeEditor.style.display = 'block'; // 确保显示
      codeEditor.contentEditable = 'true'; // 恢复编辑功能
      codeEditor.style.cursor = 'text'; // 恢复文本光标
      codeEditor.classList.remove('unsupported-file', 'large-file'); // 移除特殊样式类
      
      // 显示行号
      const lineNumbers = document.querySelector('.line-numbers');
      if (lineNumbers) {
        lineNumbers.style.display = 'block';
      }
      
      // 重新初始化编辑器布局
      initializeEditorLayout();
      
      // 应用代码高亮
      this.applySyntaxHighlighting(content);
      
      setTimeout(() => {
        try {
          updateLineNumbers();
          preciseAlignLineNumbers(); // 确保精确对齐
          ensureScrollSync();
          forceRecalculateEditorScroll();
          // 强制同步行号容器高度
          forceSyncLineNumbersHeight();
          
          // 测试编辑器是否可交互
          console.log('编辑器状态测试:', {
            content: codeElement.textContent,
            display: codeEditor.style.display,
            canFocus: codeEditor.contentEditable === 'true',
            lineCount: content ? content.split('\n').length : 0
          });
        } catch (error) {
          console.warn('showTextFile: 编辑器布局更新失败:', error);
        }
      }, 0);
      
    } catch (error) {
      console.error('showTextFile: 显示文本文件失败:', error);
    }
  }

  // 应用语法高亮
  applySyntaxHighlighting(content) {
    let codeEditor = document.getElementById('code-editor');
    const codeElement = codeEditor.querySelector('code');
    if (!codeEditor || !codeElement) {
      console.warn('applySyntaxHighlighting: 找不到代码元素');
      return;
    }
    
    // 获取当前文件扩展名
    let language = 'plaintext';
    try {
      if (this.currentFile && this.currentFile.path) {
        const extension = this.currentFile.path.split('.').pop()?.toLowerCase();
        language = this.getLanguageFromExtension(extension);
      }
    } catch (error) {
      console.warn('applySyntaxHighlighting: 获取文件扩展名失败:', error);
      language = 'plaintext';
    }
    
    // 设置语言类（仅用于标识，不进行高亮）
    codeElement.className = `language-${language}`;
    codeElement.textContent = content;
    
    console.log('代码内容设置完成:', {
      language: language,
      contentLength: content ? content.length : 0,
      lines: content ? content.split('\n').length : 0,
      currentFile: this.currentFile ? this.currentFile.path : 'null'
    });
  }

  // 根据文件扩展名获取语言
  getLanguageFromExtension(extension) {
    if (!extension) return 'plaintext';
    const languageMap = {
      'js': 'javascript',
      'ts': 'typescript',
      'jsx': 'jsx',
      'tsx': 'tsx',
      'html': 'html',
      'htm': 'html',
      'css': 'css',
      'scss': 'scss',
      'sass': 'sass',
      'less': 'less',
      'json': 'json',
      'xml': 'xml',
      'py': 'python',
      'java': 'java',
      'cpp': 'cpp',
      'c': 'c',
      'h': 'c',
      'rs': 'rust',
      'go': 'go',
      'php': 'php',
      'rb': 'ruby',
      'sh': 'bash',
      'bash': 'bash',
      'zsh': 'bash',
      'md': 'markdown',
      'txt': 'plaintext',
      'sql': 'sql',
      'vue': 'vue',
      'svelte': 'svelte',
      'yaml': 'yaml',
      'yml': 'yaml',
      'toml': 'toml',
      'ini': 'ini',
      'conf': 'ini',
      'cfg': 'ini',
      'log': 'plaintext'
    };
    return languageMap[extension] || 'plaintext';
  }

  // 激活标签
  activateTab(path) {
    const tabs = document.querySelectorAll('.tab');
    let activeTab = null;
    
    tabs.forEach(tab => {
      tab.classList.remove('active');
      if (tab.getAttribute('data-path') === path) {
        tab.classList.add('active');
        activeTab = tab;
      }
    });
    
    // 滚动到激活的标签
    if (activeTab) {
      setTimeout(() => {
        scrollToTab(activeTab);
      }, 50);
    }
  }
  
  // 调整标签位置，确保激活的标签可见
  scrollToActiveTab(activeTab) {
    // 使用VSCode风格的滚动方法
    scrollToTab(activeTab);
  }

  // 关闭标签
  async closeTab(path) {
    console.log('尝试关闭标签，路径:', path);
    
    // 调试：显示所有标签
    const allTabs = document.querySelectorAll('.tab');
    console.log('所有标签:', allTabs);
    allTabs.forEach((tab, index) => {
      console.log(`标签 ${index}:`, {
        element: tab,
        dataPath: tab.getAttribute('data-path'),
        className: tab.className,
        textContent: tab.textContent
      });
    });
    
    // 使用JavaScript方法查找标签，避免CSS选择器的问题
    const tab = Array.from(allTabs).find(tab => tab.getAttribute('data-path') === path);
    console.log('找到的标签元素:', tab);
    
    if (tab) {
      // 检查是否是当前激活的标签
      const isActive = tab.classList.contains('active');
      console.log('标签是否激活:', isActive);
      
      // 移除标签
      tab.remove();
      this.openFiles.delete(path);
      console.log('标签已从DOM移除，文件缓存已清理');
      
      // 如果关闭的是当前文件，清空编辑器
      if (this.currentFile && this.currentFile.path === path) {
        this.currentFile = null;
        let codeEditor = document.getElementById('code-editor');
        if (codeEditor) {
          // 恢复文本编辑器显示
          codeEditor.style.display = 'block';
          codeEditor.value = '';
          updateLineNumbers();
          updateTitleBarFileName('');
          console.log('当前文件已清空');
        }
        
        // 清除图片预览
        const editorArea = document.querySelector('.editor-area');
        if (editorArea) {
          const imageWrapper = editorArea.querySelector('.image-preview-wrapper');
          if (imageWrapper) {
            imageWrapper.remove();
          }
        }
      }
      
      // 如果关闭的是激活标签，切换到其他标签
      if (isActive) {
        const remainingTabs = document.querySelectorAll('.tab');
        console.log('剩余标签数量:', remainingTabs.length);
        
        if (remainingTabs.length > 0) {
          // 切换到最后一个标签
          const lastTab = remainingTabs[remainingTabs.length - 1];
          const lastPath = lastTab.getAttribute('data-path');
          console.log('切换到标签:', lastPath);
          await this.switchToTab(lastPath);
          
          // 确保新激活的标签可见
          setTimeout(() => {
            const newActiveTab = document.querySelector(`.tab[data-path="${lastPath}"]`);
            if (newActiveTab) {
              scrollToTab(newActiveTab);
            }
          }, 50);
          

        } else {
          // 没有标签了，清空编辑器
          this.currentFile = null;
          let codeEditor = document.getElementById('code-editor');
          if (codeEditor) {
            // 恢复文本编辑器显示
            codeEditor.style.display = 'block';
            codeEditor.value = '';
            updateLineNumbers();
            updateTitleBarFileName('');
            console.log('没有剩余标签，编辑器已清空');
          }
          
          // 清除图片预览
          const editorArea = document.querySelector('.editor-area');
          if (editorArea) {
            const imageWrapper = editorArea.querySelector('.image-preview-wrapper');
            if (imageWrapper) {
              imageWrapper.remove();
            }
          }
          
          // 重置标签栏滚动位置
          const tabList = document.querySelector('.tab-list');
          if (tabList) {
            tabList.style.transform = '';
          }
          
          // 确保欢迎页面可以正常显示
          setTimeout(() => {
            updateWelcomeMessage();
          }, 50);
        }
      } else {
        // 如果关闭的不是激活标签，重新计算滚动位置
        setTimeout(() => {
          const activeTab = document.querySelector('.tab.active');
          if (activeTab) {
            scrollToTab(activeTab);
          }
        }, 50);
      }
      
      // 更新滚动按钮状态
      setTimeout(() => {
        updateTabScrollButtons();
      }, 100);
      
      // 更新欢迎语句显示状态
      updateWelcomeMessage();
      
      console.log('标签关闭完成:', path);
    } else {
      console.error('未找到要关闭的标签:', path);
      console.error('要查找的路径:', path);
    }
  }

  // 检查是否为图片文件
  isImageFile(fileName) {
    const extension = fileName.split('.').pop()?.toLowerCase();
    const imageExtensions = ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'webp', 'svg', 'ico'];
    return imageExtensions.includes(extension);
  }

  // 显示图片预览
  async showImagePreview(path, name) {
    console.log('显示图片预览:', path, name);
    
    try {
      // 直接清理图片预览容器，不调用clearCurrentDisplay避免闪烁
      const editorArea = document.querySelector('.editor-area');
      if (editorArea) {
        const imageWrapper = editorArea.querySelector('.image-preview-wrapper');
        if (imageWrapper) {
          imageWrapper.remove();
        }
      }
      
      // 使用Rust后端读取图片文件并转换为base64
      const imageData = await invoke('read_image_file', { path });
      console.log('图片数据读取成功，MIME类型:', imageData.mime_type);
      
      // 创建base64图片URL
      const imageUrl = `data:${imageData.mime_type};base64,${imageData.content}`;
      
      // 创建图片预览的HTML内容
      const imagePreviewHTML = `
        <div class="image-preview-container">
          <div class="image-preview-header">
            <h3>图片预览: ${name}</h3>
          </div>
          <div class="image-preview-content">
            <img src="${imageUrl}" alt="${name}" class="image-preview-img" onerror="this.style.display='none'; this.nextElementSibling.style.display='block';" />
            <div class="image-load-error" style="display: none; text-align: center; color: #ff6b6b; padding: 20px;">
              <i class="fas fa-exclamation-triangle" style="font-size: 48px; margin-bottom: 10px;"></i>
              <p>图片加载失败</p>
              <p style="font-size: 12px; color: #858585;">可能是由于文件路径或权限问题</p>
            </div>
          </div>
          <div class="image-preview-info">
            <p><strong>文件路径:</strong> ${path}</p>
            <p><strong>文件名称:</strong> ${name}</p>
            <p><strong>文件类型:</strong> 图片文件</p>
            <p><strong>MIME类型:</strong> ${imageData.mime_type}</p>
          </div>
        </div>
      `;
      
      // 更新编辑器内容为图片预览
      let codeEditor = document.getElementById('code-editor');
      if (codeEditor) {
        // 隐藏文本编辑器，显示图片预览
        codeEditor.style.display = 'none';
        
        // 隐藏行号
        const lineNumbers = document.querySelector('.line-numbers');
        if (lineNumbers) {
          lineNumbers.style.display = 'none';
        }
        
        // 获取编辑器区域容器
        const editorArea = document.querySelector('.editor-area');
        if (editorArea) {
          // 确保文本编辑器隐藏
          const codeEditor = editorArea.querySelector('#code-editor');
          if (codeEditor) {
            codeEditor.style.display = 'none';
          }
          
          // 创建图片预览容器
          const imageContainer = document.createElement('div');
          imageContainer.className = 'image-preview-wrapper';
          imageContainer.innerHTML = imagePreviewHTML;
          editorArea.appendChild(imageContainer);
        }
      }
      
      // 更新标签栏（标记为图片文件）
      this.updateTabBar(path, name, false, false, true);
      
      // 更新标题栏
      updateTitleBarFileName(name);
      
      // 缓存当前文件信息
      this.currentFile = { path, name, type: 'image' };
      
      // 将图片文件添加到缓存中，以便标签切换时能找到
      this.openFiles.set(path, { path, name, type: 'image', content: '' });
      
      // 动态调整图片预览容器大小
      updateImagePreviewHeight();
      
      console.log('图片预览已显示，文件已缓存');
    } catch (error) {
      console.error('显示图片预览失败:', error);
      // 如果图片显示失败，显示错误信息
      this.showImageError(path, name, error.message);
    }
  }

  // 显示图片错误信息
  showImageError(path, name, errorMessage) {
    const errorHTML = `
      <div class="image-preview-container">
        <div class="image-preview-header">
          <h3>图片预览失败: ${name}</h3>
        </div>
        <div class="image-preview-content">
          <div class="image-load-error" style="text-align: center; color: #ff6b6b; padding: 40px;">
            <i class="fas fa-exclamation-triangle" style="font-size: 64px; margin-bottom: 20px;"></i>
            <h4>图片加载失败</h4>
            <p style="font-size: 14px; color: #858585; margin-bottom: 20px;">${errorMessage || '无法加载图片文件'}</p>
          </div>
        </div>
        <div class="image-preview-info">
          <p><strong>文件路径:</strong> ${path}</p>
          <p><strong>文件名称:</strong> ${name}</p>
          <p><strong>错误信息:</strong> ${errorMessage || '未知错误'}</p>
        </div>
      </div>
    `;
    
    // 更新编辑器内容为错误信息
    let codeEditor = document.getElementById('code-editor');
    if (codeEditor) {
      codeEditor.style.display = 'none';
      
      // 隐藏行号
      const lineNumbers = document.querySelector('.line-numbers');
      if (lineNumbers) {
        lineNumbers.style.display = 'none';
      }
      
      const editorArea = document.querySelector('.editor-area');
      if (editorArea) {
        // 清理现有的图片预览容器
        const imageWrapper = editorArea.querySelector('.image-preview-wrapper');
        if (imageWrapper) {
          imageWrapper.remove();
        }
        
        const errorContainer = document.createElement('div');
        errorContainer.className = 'image-preview-wrapper';
        errorContainer.innerHTML = errorHTML;
        editorArea.appendChild(errorContainer);
      }
    }
    
    // 更新标签栏
    this.updateTabBar(path, name, false, false, true);
    updateTitleBarFileName(name);
    this.currentFile = { path, name, type: 'image' };
    
    // 将图片文件添加到缓存中
    this.openFiles.set(path, { path, name, type: 'image', content: '' });
    
    // 动态调整图片预览容器大小
    updateImagePreviewHeight();
  }



  // 获取文件图标
  getFileIcon(extension) {
    if (!extension) return 'fa-file';
    
    const iconMap = {
      'js': 'fa-file-code',
      'ts': 'fa-file-code',
      'html': 'fa-file-code',
      'css': 'fa-file-code',
      'json': 'fa-file-code',
      'xml': 'fa-file-code',
      'py': 'fa-file-code',
      'java': 'fa-file-code',
      'cpp': 'fa-file-code',
      'c': 'fa-file-code',
      'rs': 'fa-file-code',
      'md': 'fa-file-alt',
      'txt': 'fa-file-alt',
      'pdf': 'fa-file-pdf',
      'png': 'fa-file-image',
      'jpg': 'fa-file-image',
      'jpeg': 'fa-file-image',
      'gif': 'fa-file-image',
      'svg': 'fa-file-image',
      'zip': 'fa-file-archive',
      'rar': 'fa-file-archive',
      '7z': 'fa-file-archive'
    };
    
    return iconMap[extension.toLowerCase()] || 'fa-file';
  }

  // 检查文件内容是否为人类可读的文本
  isTextContent(content) {
    if (!content || content.length === 0) return true;
    
    // 确保content是字符串类型
    if (typeof content !== 'string') {
      console.log('内容不是字符串类型:', typeof content);
      return false;
    }
    
    console.log('检查文件内容，长度:', content.length);
    console.log('内容前100个字符:', content.substring(0, 100));
    
    // 检查是否包含大量不可打印字符
    const nonPrintableChars = content.match(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g);
    if (nonPrintableChars) {
      console.log('不可打印字符数量:', nonPrintableChars.length);
      console.log('不可打印字符比例:', (nonPrintableChars.length / content.length * 100).toFixed(2) + '%');
    }
    
    if (nonPrintableChars && nonPrintableChars.length > content.length * 0.1) {
      console.log('检测到二进制文件：不可打印字符过多');
      return false; // 超过10%的不可打印字符，认为是二进制文件
    }
    
    // 检查是否包含大量空字节
    const nullBytes = content.match(/\x00/g);
    if (nullBytes) {
      console.log('空字节数量:', nullBytes.length);
    }
    
    if (nullBytes && nullBytes.length > 0) {
      console.log('检测到二进制文件：包含空字节');
      return false; // 包含空字节，认为是二进制文件
    }
    
    // 检查是否包含大量控制字符（除了常见的换行、制表符等）
    const controlChars = content.match(/[\x01-\x08\x0B\x0C\x0E-\x1F\x7F]/g);
    if (controlChars) {
      console.log('控制字符数量:', controlChars.length);
      console.log('控制字符比例:', (controlChars.length / content.length * 100).toFixed(2) + '%');
    }
    
    if (controlChars && controlChars.length > content.length * 0.05) {
      console.log('检测到二进制文件：控制字符过多');
      return false; // 超过5%的控制字符，认为是二进制文件
    }
    
    console.log('文件内容检测为文本');
    return true;
  }

  // 检查文件是否支持预览（基于内容而不是扩展名）
  async isFilePreviewable(path) {
    try {
      // 首先尝试读取文件内容
      const content = await this.readFile(path);
      
      // 检查内容是否为可读文本
      return this.isTextContent(content);
    } catch (error) {
      console.error('检查文件可读性失败:', error);
      return false;
    }
  }

  // 获取不支持预览文件的提示信息
  getUnsupportedFileMessage(fileType, fileName) {
    // 根据检测到的文件类型提供相应的提示
    if (fileType.includes('可执行文件') || fileType.includes('安装程序')) {
      return `此文件 (${fileName}) 是一个可执行文件，无法在编辑器中预览。

要运行此文件，请使用终端或文件资源管理器。`;
    }
    
    if (fileType.includes('压缩文件')) {
      return `此文件 (${fileName}) 是一个压缩文件，无法在编辑器中预览。

要查看压缩文件内容，请先解压缩文件。`;
    }
    
    if (fileType.includes('图片')) {
      return `此文件 (${fileName}) 是一个图片文件，无法在编辑器中预览。

要查看图片，请使用图片查看器或文件资源管理器。`;
    }
    
    if (fileType.includes('视频')) {
      return `此文件 (${fileName}) 是一个视频文件，无法在编辑器中预览。

要播放视频，请使用视频播放器。`;
    }
    
    if (fileType.includes('音频')) {
      return `此文件 (${fileName}) 是一个音频文件，无法在编辑器中预览。

要播放音频，请使用音频播放器。`;
    }
    
    if (fileType.includes('文档') || fileType.includes('PDF') || fileType.includes('Word') || fileType.includes('Excel') || fileType.includes('PowerPoint')) {
      return `此文件 (${fileName}) 是一个文档文件，无法在编辑器中预览。

要查看文档，请使用相应的文档查看器。`;
    }
    
    // 默认提示
    return `此文件 (${fileName}) 包含二进制数据，无法在编辑器中预览。

检测到的文件类型: ${fileType}
建议使用合适的应用程序打开此文件。`;
  }

  // 格式化文件大小
  formatFileSize(bytes) {
    if (bytes === 0) return '0 B';
    const k = 1024;
    const sizes = ['B', 'KB', 'MB', 'GB'];
    const i = Math.floor(Math.log(bytes) / Math.log(k));
    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
  }

  // 在编辑器中打开文件（用于新建文件）
  openFileInEditor(fileName, content) {
    // 设置当前文件信息
    this.currentFile = { path: fileName, name: fileName, content: content || '' };
    
    // 将文件添加到缓存中
    this.openFiles.set(fileName, { path: fileName, name: fileName, content: content || '' });
    
    this.updateTabBar(fileName, fileName);
    
    // 使用showTextFile方法显示文件内容，确保应用代码高亮
    this.showTextFile(content || '');
    
    updateTitleBarFileName(fileName);
  }
}

  // 清空标题栏文件名
  updateTitleBarFileName('');
  
  // 添加标签关闭按钮的全局事件监听器（备用方案）
  document.addEventListener('click', async (e) => {
    if (e.target.classList.contains('tab-close-btn')) {
      console.log('全局事件：关闭按钮被点击');
      e.stopPropagation();
      e.preventDefault();
      const path = e.target.getAttribute('data-path');
      if (path) {
        await fileSystem.closeTab(path);
      }
    }
  });

// 监听窗口状态变化
// appWindow.onResized(() => {
//   console.log('窗口大小已改变');
//   // 窗口大小改变时更新行号
//   setTimeout(updateLineNumbers, 100);
// });

// appWindow.onMoved(() => {
//   console.log('窗口位置已改变');
// });

// 监听窗口焦点状态
// appWindow.onWindowEvent('tauri://focus', () => {
//   document.querySelector('.title-bar').classList.remove('inactive');
// });

// appWindow.onWindowEvent('tauri://blur', () => {
//   document.querySelector('.title-bar').classList.add('inactive');
// });

// 检查窗口是否最大化
// appWindow.isMaximized().then(maximized => {
//   const container = document.querySelector('.vscode-container');
//   const maximizeBtn = document.querySelector('.window-control.maximize i');
  
//   if (maximized) {
//     container.classList.add('maximized');
//     if (maximizeBtn) {
//       maximizeBtn.className = 'fas fa-window-restore';
//     }
//   }
// });

// // 监听最大化状态变化
// appWindow.onWindowEvent('tauri://resize', () => {
//   appWindow.isMaximized().then(maximized => {
//     const container = document.querySelector('.vscode-container');
//     const maximizeBtn = document.querySelector('.window-control.maximize i');
    
//     if (maximized) {
//       container.classList.add('maximized');
//       if (maximizeBtn) {
//         maximizeBtn.className = 'fas fa-window-restore';
//       }
//     } else {
//       container.classList.remove('maximized');
//       if (maximizeBtn) {
//         maximizeBtn.className = 'fas fa-window-maximize';
//       }
//     }
//   });
// });

// 初始化菜单栏
function initializeMenuBar() {
  console.log('开始初始化菜单栏...');
  const menuItems = document.querySelectorAll('.menu-item');
  console.log('找到菜单项数量:', menuItems.length);
  // 使用全局变量来管理activeMenu
  window.activeMenu = null;

  // 先移除所有现有的事件监听器
  menuItems.forEach(menuItem => {
    const newMenuItem = menuItem.cloneNode(true);
    menuItem.parentNode.replaceChild(newMenuItem, menuItem);
  });

  // 重新获取菜单项
  const freshMenuItems = document.querySelectorAll('.menu-item');
  console.log('重新获取菜单项数量:', freshMenuItems.length);

  // 为每个菜单项添加点击事件
  freshMenuItems.forEach(menuItem => {
    const menuText = menuItem.querySelector('span').textContent;
    console.log('为菜单项添加事件监听器:', menuText);
    
    menuItem.onclick = function(e) {
      console.log('菜单项被点击:', this.querySelector('span').textContent);
      e.preventDefault();
      e.stopPropagation();
      
      const dropdown = this.querySelector('.menu-dropdown');
      console.log('找到下拉菜单:', dropdown);
      
      // 如果点击的是当前激活的菜单，则关闭它
      if (window.activeMenu === this) {
        console.log('关闭当前菜单');
        closeAllMenus();
        window.activeMenu = null;
        return;
      }
      
      // 关闭其他菜单（包括右键菜单）
      closeAllMenus();
      hideAllContextMenus();
      
      // 打开当前菜单
      if (dropdown) {
        console.log('显示下拉菜单');
        dropdown.classList.add('show');
        this.classList.add('active');
        window.activeMenu = this;
      }
    };
  });

  // 为下拉菜单项添加点击事件
  document.addEventListener('click', function(e) {
    console.log('全局点击事件触发，目标元素:', e.target);
    console.log('目标元素的类名:', e.target.className);
    
    const menuItem = e.target.closest('.menu-dropdown-item');
    console.log('找到的菜单项:', menuItem);
    
    if (menuItem) {
      console.log('菜单项被点击，action:', menuItem.getAttribute('data-action'));
      e.stopPropagation();
      e.preventDefault();
      const action = menuItem.getAttribute('data-action');
      console.log('执行菜单动作:', action);
      handleMenuAction(action);
      closeAllMenus();
    } else {
      console.log('未找到菜单项，目标不是菜单项');
    }
  });

  // 直接为菜单项添加事件监听器（备用方案）
  const menuDropdownItems = document.querySelectorAll('.menu-dropdown-item');
  console.log('找到菜单项数量:', menuDropdownItems.length);
  
  menuDropdownItems.forEach(item => {
    console.log('为菜单项添加事件监听器:', item.textContent.trim());
    item.addEventListener('click', function(e) {
      console.log('菜单项直接点击事件触发:', this.textContent.trim());
      e.stopPropagation();
      e.preventDefault();
      const action = this.getAttribute('data-action');
      console.log('执行菜单动作:', action);
      handleMenuAction(action);
      closeAllMenus();
    });
  });

  // 点击其他地方关闭菜单
  document.addEventListener('click', function(e) {
    // 如果点击的是右键菜单或其子元素，不关闭菜单
    if (e.target.closest('.context-menu')) {
      return;
    }
    if (!e.target.closest('.menu-item')) {
      closeAllMenus();
      hideAllContextMenus();
    }
  });

  // 关闭所有菜单
  function closeAllMenus() {
    document.querySelectorAll('.menu-dropdown').forEach(dropdown => {
      dropdown.classList.remove('show');
    });
    document.querySelectorAll('.menu-item').forEach(item => {
      item.classList.remove('active');
    });
    window.activeMenu = null;
  }
}

// 全局菜单关闭函数
function closeAllMenus() {
  document.querySelectorAll('.menu-dropdown').forEach(dropdown => {
    dropdown.classList.remove('show');
  });
  document.querySelectorAll('.menu-item').forEach(item => {
    item.classList.remove('active');
  });
  // 重置菜单栏的activeMenu状态
  if (typeof window.activeMenu !== 'undefined') {
    window.activeMenu = null;
  }
}

// 全局右键菜单关闭函数
function hideAllContextMenus() {
  const tabContextMenu = document.getElementById('tab-context-menu');
  const fileContextMenu = document.getElementById('file-context-menu');
  const editorContextMenu = document.getElementById('editor-context-menu');
  
  if (tabContextMenu) tabContextMenu.classList.remove('show');
  if (fileContextMenu) fileContextMenu.classList.remove('show');
  if (editorContextMenu) editorContextMenu.classList.remove('show');
}

// 初始化菜单栏
console.log('准备初始化菜单栏...');
console.log('initializeMenuBar函数是否存在:', typeof initializeMenuBar);

// 初始化代码编辑器
function initializeCodeEditor() {
  console.log('初始化代码编辑器...');
  
  // 初始化代码编辑器元素
  let codeEditor = document.getElementById('code-editor');
  if (codeEditor) {
    const codeElement = codeEditor.querySelector('code');
    if (codeElement) {
      codeElement.className = 'language-plaintext';
      codeElement.textContent = '';
    }
    
    // 添加滚动事件监听器
    codeEditor.addEventListener('scroll', syncScroll);
    console.log('已添加编辑器滚动事件监听器');
  }
}

// 控制欢迎语句显示的函数
function updateWelcomeMessage() {
  const welcomeMessage = document.getElementById('welcome-message');
  const tabList = document.getElementById('tab-list');
  const lineNumbers = document.querySelector('.line-numbers');
  
  if (!welcomeMessage || !tabList) return;
  
  const hasTabs = tabList.children.length > 0;
  
  if (hasTabs) {
    welcomeMessage.style.display = 'none';
    // 显示行号容器
    if (lineNumbers) {
      lineNumbers.style.display = 'block';
    }
  } else {
    // 确保编辑器区域干净，没有图片预览容器
    const editorArea = document.querySelector('.editor-area');
    if (editorArea) {
      const imageWrapper = editorArea.querySelector('.image-preview-wrapper');
      if (imageWrapper) {
        imageWrapper.remove();
      }
    }
    
    // 确保文本编辑器隐藏
    const codeEditor = document.getElementById('code-editor');
    if (codeEditor) {
      codeEditor.style.display = 'none';
    }
    
    welcomeMessage.style.display = 'flex';
    // 隐藏行号容器
    if (lineNumbers) {
      lineNumbers.style.display = 'none';
    }
  }
}

// 全局菜单动作实现函数
function createNewFile() {
  const fileName = `untitled-${Date.now()}.txt`;
  fileSystem.openFileInEditor(fileName, '');
}

function openFile() {
  // 这里可以调用 Tauri 的文件选择器
  console.log('打开文件');
}

function openFolder() {
  // 这里可以调用 Tauri 的文件夹选择器
  console.log('打开文件夹');
}

function saveCurrentFile() {
  const activeTab = document.querySelector('.tab.active');
  if (activeTab) {
    const fileName = activeTab.getAttribute('data-file');
    const codeEditor = document.getElementById('code-editor');
    const codeElement = codeEditor.querySelector('code');
    const content = codeElement ? codeElement.textContent : '';
    // 这里可以调用 Tauri 的保存文件功能
    console.log('保存文件:', fileName);
  }
}

function saveFileAs() {
  console.log('另存为');
}

function showFindDialog() {
  console.log('显示查找对话框');
}

function showReplaceDialog() {
  console.log('显示替换对话框');
}

function expandSelection() {
  console.log('扩展选择');
}

function shrinkSelection() {
  console.log('缩小选择');
}

function toggleSidebar() {
  const sidebar = document.querySelector('.sidebar');
  sidebar.style.display = sidebar.style.display === 'none' ? 'flex' : 'none';
}

function zoomIn() {
  const editor = document.getElementById('code-editor');
  const codeElement = editor.querySelector('code');
  const currentSize = parseInt(window.getComputedStyle(codeElement).fontSize);
  codeElement.style.fontSize = (currentSize + 2) + 'px';
}

function zoomOut() {
  const editor = document.getElementById('code-editor');
  const codeElement = editor.querySelector('code');
  const currentSize = parseInt(window.getComputedStyle(codeElement).fontSize);
  if (currentSize > 8) {
    codeElement.style.fontSize = (currentSize - 2) + 'px';
  }
}

function resetZoom() {
  const editor = document.getElementById('code-editor');
  const codeElement = editor.querySelector('code');
  codeElement.style.fontSize = '14px';
}

function startDebugging() {
  console.log('开始调试');
}

function startWithoutDebugging() {
  console.log('开始执行（不调试）');
}

function stopExecution() {
  console.log('停止执行');
}

function restartExecution() {
  console.log('重启执行');
}

function splitTerminal() {
  console.log('拆分终端');
}

function killTerminal() {
  console.log('终止终端');
}

function showWelcome() {
  console.log('显示欢迎页面');
}

function showDocumentation() {
  console.log('显示文档');
}

function showAbout() {
  console.log('显示关于对话框');
  const modal = document.getElementById('about-modal');
  if (modal) {
    modal.classList.add('show');
    
    // 添加ESC键关闭功能
    const handleEscape = (e) => {
      if (e.key === 'Escape') {
        hideAboutModal();
        document.removeEventListener('keydown', handleEscape);
      }
    };
    document.addEventListener('keydown', handleEscape);
    
    // 添加点击遮罩关闭功能
    modal.addEventListener('click', (e) => {
      if (e.target === modal) {
        hideAboutModal();
      }
    });
  }
}

function hideAboutModal() {
  const modal = document.getElementById('about-modal');
  if (modal) {
    modal.classList.remove('show');
  }
}

function initAboutModal() {
  const closeButton = document.getElementById('about-modal-close');
  if (closeButton) {
    closeButton.addEventListener('click', hideAboutModal);
    console.log('关于模态弹窗关闭按钮已初始化');
  }
}

// 新建终端函数
function createNewTerminal() {
  console.log('createNewTerminal 被调用');
  
  // 确保终端面板可见
  const terminalPanel = document.getElementById('terminal-panel');
  console.log('找到终端面板:', terminalPanel);
  
  if (terminalPanel) {
    console.log('终端面板当前状态:');
    console.log('- 类名:', terminalPanel.className);
    console.log('- display:', terminalPanel.style.display);
    console.log('- visibility:', terminalPanel.style.visibility);
    console.log('- height:', terminalPanel.style.height);
    console.log('- 是否包含hidden类:', terminalPanel.classList.contains('hidden'));
    console.log('- 是否包含minimized类:', terminalPanel.classList.contains('minimized'));
    
    // 强制移除所有可能隐藏终端的类
    terminalPanel.classList.remove('hidden');
    terminalPanel.classList.remove('minimized');
    
    // 强制设置显示样式（覆盖内联样式和CSS类）
    terminalPanel.style.display = 'flex';
    terminalPanel.style.visibility = 'visible';
    terminalPanel.style.opacity = '1';
    terminalPanel.style.position = 'relative';
    terminalPanel.style.zIndex = '1';
    
    // 确保终端面板有合适的高度
    if (!terminalPanel.style.height || terminalPanel.style.height === '0px' || terminalPanel.style.height === '25px') {
      terminalPanel.style.height = '200px';
    }
    
    // 强制重新计算布局
    terminalPanel.offsetHeight; // 触发重排
    
    console.log('终端面板处理后状态:');
    console.log('- 类名:', terminalPanel.className);
    console.log('- display:', terminalPanel.style.display);
    console.log('- visibility:', terminalPanel.style.visibility);
    console.log('- height:', terminalPanel.style.height);
    console.log('- offsetHeight:', terminalPanel.offsetHeight);
    console.log('- clientHeight:', terminalPanel.clientHeight);
    console.log('- scrollHeight:', terminalPanel.scrollHeight);
    
    // 检查父元素
    const editorArea = terminalPanel.parentElement;
    console.log('编辑器区域状态:');
    console.log('- 类名:', editorArea.className);
    console.log('- display:', editorArea.style.display);
    console.log('- height:', editorArea.style.height);
    console.log('- offsetHeight:', editorArea.offsetHeight);
    
  } else {
    console.error('未找到终端面板元素！');
    // 尝试重新查找
    const allTerminalPanels = document.querySelectorAll('.terminal-panel');
    console.log('页面中所有terminal-panel元素:', allTerminalPanels);
  }
  
  // 创建新终端
  newTerminal();
}

// 标签页滚动功能
let tabScrollOffset = 0;
const tabScrollStep = 200; // 每次滚动的距离

// 初始化标签页滚动功能
function initTabScrolling() {
  const tabScrollLeft = document.getElementById('tab-scroll-left');
  const tabScrollRight = document.getElementById('tab-scroll-right');
  const tabList = document.getElementById('tab-list');
  
  if (!tabScrollLeft || !tabScrollRight || !tabList) return;
  
  // 左滚动按钮事件
  tabScrollLeft.addEventListener('click', () => {
    scrollTabsLeft();
  });
  
  // 右滚动按钮事件
  tabScrollRight.addEventListener('click', () => {
    scrollTabsRight();
  });
  
  // 初始检查滚动按钮状态
  updateTabScrollButtons();
  
  // 监听窗口大小变化
  window.addEventListener('resize', () => {
    setTimeout(updateTabScrollButtons, 100);
  });
}

// 向左滚动标签页
function scrollTabsLeft() {
  const tabList = document.getElementById('tab-list');
  if (!tabList) return;
  
  console.log('向左滚动:', {
    currentOffset: tabScrollOffset,
    step: tabScrollStep,
    newOffset: Math.max(0, tabScrollOffset - tabScrollStep)
  });
  
  tabScrollOffset = Math.max(0, tabScrollOffset - tabScrollStep);
  tabList.style.transform = `translateX(-${tabScrollOffset}px)`;
  updateTabScrollButtons();
}

// 向右滚动标签页
function scrollTabsRight() {
  const tabList = document.getElementById('tab-list');
  const scrollContainer = tabList.parentElement;
  if (!tabList || !scrollContainer) return;
  
  // 计算所有标签的总宽度
  const allTabs = Array.from(tabList.children);
  let totalWidth = 0;
  allTabs.forEach(tab => {
    totalWidth += tab.offsetWidth;
  });
  
  // 计算最大滚动距离 - 使用父容器的可见宽度
  const visibleWidth = scrollContainer.clientWidth;
  const maxScroll = Math.max(0, totalWidth - visibleWidth);
  
  console.log('向右滚动:', {
    currentOffset: tabScrollOffset,
    step: tabScrollStep,
    maxScroll,
    newOffset: Math.min(maxScroll, tabScrollOffset + tabScrollStep),
    totalWidth,
    visibleWidth
  });
  
  tabScrollOffset = Math.min(maxScroll, tabScrollOffset + tabScrollStep);
  tabList.style.transform = `translateX(-${tabScrollOffset}px)`;
  updateTabScrollButtons();
}

// 更新滚动按钮状态
function updateTabScrollButtons() {
  const tabScrollLeft = document.getElementById('tab-scroll-left');
  const tabScrollRight = document.getElementById('tab-scroll-right');
  const tabList = document.getElementById('tab-list');
  const scrollContainer = tabList.parentElement;
  
  if (!tabScrollLeft || !tabScrollRight || !tabList || !scrollContainer) return;
  
  // 计算所有标签的总宽度
  const allTabs = Array.from(tabList.children);
  let totalWidth = 0;
  allTabs.forEach(tab => {
    totalWidth += tab.offsetWidth;
  });
  
  // 计算标签列表的可见宽度 - 使用父容器的可见宽度
  const visibleWidth = scrollContainer.clientWidth;
  const maxScroll = Math.max(0, totalWidth - visibleWidth);
  
  console.log('更新滚动按钮状态:', {
    totalWidth,
    visibleWidth,
    maxScroll,
    tabScrollOffset,
    totalTabs: allTabs.length,
    needsScrolling: maxScroll > 0
  });
  
  // 如果不需要滚动，隐藏按钮并重置位置
  if (maxScroll <= 0) {
    tabScrollLeft.style.display = 'none';
    tabScrollRight.style.display = 'none';
    // 重置滚动偏移
    tabScrollOffset = 0;
    tabList.style.transform = '';
    console.log('不需要滚动，隐藏按钮并重置位置');
  } else {
    tabScrollLeft.style.display = 'flex';
    tabScrollRight.style.display = 'flex';
    
    // 更新左滚动按钮状态
    if (tabScrollOffset <= 0) {
      tabScrollLeft.classList.add('disabled');
    } else {
      tabScrollLeft.classList.remove('disabled');
    }
    
    // 更新右滚动按钮状态
    if (tabScrollOffset >= maxScroll) {
      tabScrollRight.classList.add('disabled');
    } else {
      tabScrollRight.classList.remove('disabled');
    }
    
    console.log('需要滚动，显示按钮');
  }
}





// VSCode风格的滚动到标签页方法
function scrollToTab(targetTab) {
  if (!targetTab) {
    console.warn('scrollToTab: targetTab 为空');
    return;
  }
  
  const tabList = document.getElementById('tab-list');
  if (!tabList) {
    console.warn('scrollToTab: 找不到 tab-list 元素');
    return;
  }
  
  const scrollContainer = tabList.parentElement;
  if (!scrollContainer) {
    console.warn('scrollToTab: 找不到滚动容器');
    return;
  }
  
  // 计算标签在标签列表中的相对位置
  const allTabs = Array.from(tabList.children);
  const targetIndex = allTabs.indexOf(targetTab);
  
  if (targetIndex === -1) {
    console.warn('scrollToTab: 目标标签不在标签列表中');
    return;
  }
  
  // 计算目标标签的绝对位置（相对于标签列表）
  let targetTabPosition = 0;
  for (let i = 0; i < targetIndex; i++) {
    targetTabPosition += allTabs[i].offsetWidth;
  }
  
  // 计算标签列表的可见宽度 - 使用父容器的可见宽度
  const visibleWidth = scrollContainer.clientWidth;
  
  // VSCode风格的滚动逻辑
  const isVisible = targetTabPosition >= tabScrollOffset && 
                   targetTabPosition + targetTab.offsetWidth <= tabScrollOffset + visibleWidth;
  
  if (!isVisible) {
    let newScrollOffset;
    
    if (targetTabPosition < tabScrollOffset) {
      // 标签在左侧被隐藏，滚动到标签开始位置
      newScrollOffset = targetTabPosition;
    } else {
      // 标签在右侧被隐藏，滚动到标签结束位置
      newScrollOffset = targetTabPosition + targetTab.offsetWidth - visibleWidth;
    }
    
    // 确保滚动偏移不为负数
    newScrollOffset = Math.max(0, newScrollOffset);
    
    // 应用滚动
    tabScrollOffset = newScrollOffset;
    tabList.style.transform = `translateX(-${tabScrollOffset}px)`;
    
    console.log('滚动到标签页:', {
      targetTabPosition,
      targetTabWidth: targetTab.offsetWidth,
      visibleWidth,
      newScrollOffset,
      targetPath: targetTab.getAttribute('data-path')
    });
  }
  
  updateTabScrollButtons();
}

  // 测试标签页滚动功能
  function testTabScrolling() {
    console.log('=== 开始测试标签页滚动功能 ===');
    
    const tabList = document.getElementById('tab-list');
    const allTabs = Array.from(tabList.children);
    
    console.log('当前标签页信息:', {
      totalTabs: allTabs.length,
      tabListWidth: tabList.clientWidth,
      tabListScrollWidth: tabList.scrollWidth,
      currentScrollOffset: tabScrollOffset
    });
    
    allTabs.forEach((tab, index) => {
      console.log(`标签页 ${index}:`, {
        width: tab.offsetWidth,
        path: tab.getAttribute('data-path'),
        isActive: tab.classList.contains('active')
      });
    });
    
    // 测试滚动到最后一个标签页
    if (allTabs.length > 0) {
      const lastTab = allTabs[allTabs.length - 1];
      console.log('测试滚动到最后一个标签页:', lastTab);
      scrollToTab(lastTab);
    }
    
    console.log('=== 测试完成 ===');
  }

// 调试标签页布局
function debugTabLayout() {
  console.log('=== 调试标签页布局 ===');
  
  const tabBar = document.querySelector('.tab-bar');
  const tabList = document.getElementById('tab-list');
  const allTabs = Array.from(tabList.children);
  const editorArea = document.querySelector('.editor-area');
  const lineNumbers = document.getElementById('line-numbers');
  
  console.log('标签栏信息:', {
    width: tabBar.offsetWidth,
    height: tabBar.offsetHeight,
    style: {
      display: tabBar.style.display,
      flexDirection: tabBar.style.flexDirection,
      overflow: tabBar.style.overflow
    }
  });
  
  console.log('标签列表信息:', {
    width: tabList.offsetWidth,
    clientWidth: tabList.clientWidth,
    scrollWidth: tabList.scrollWidth,
    style: {
      transform: tabList.style.transform,
      overflow: tabList.style.overflow
    }
  });
  
  console.log('编辑器区域信息:', {
    width: editorArea.offsetWidth,
    height: editorArea.offsetHeight,
    style: {
      flex: editorArea.style.flex,
      minHeight: editorArea.style.minHeight
    }
  });
  
  console.log('行号容器信息:', {
    width: lineNumbers.offsetWidth,
    height: lineNumbers.offsetHeight,
    visible: lineNumbers.offsetParent !== null
  });
  
  let totalWidth = 0;
  allTabs.forEach((tab, index) => {
    totalWidth += tab.offsetWidth;
    console.log(`标签页 ${index}:`, {
      width: tab.offsetWidth,
      offsetLeft: tab.offsetLeft,
      path: tab.getAttribute('data-path')
    });
  });
  
  console.log('总宽度:', totalWidth, '可见宽度:', tabList.clientWidth);
  console.log('需要滚动:', totalWidth > tabList.clientWidth);
  console.log('当前滚动偏移:', tabScrollOffset);
  
  // 检查每个标签页的可见性
  allTabs.forEach((tab, index) => {
    const rect = tab.getBoundingClientRect();
    const tabListRect = tabList.getBoundingClientRect();
    const isVisible = rect.left >= tabListRect.left && rect.right <= tabListRect.right;
    console.log(`标签页 ${index} 可见性:`, isVisible, {
      left: rect.left,
      right: rect.right,
      tabListLeft: tabListRect.left,
      tabListRight: tabListRect.right
    });
  });
  
  console.log('=== 调试完成 ===');
}

// 更新图片预览容器高度
function updateImagePreviewHeight() {
  const imagePreviewWrapper = document.querySelector('.image-preview-wrapper');
  const terminalContainer = document.getElementById('terminal-container');
  
  if (imagePreviewWrapper && terminalContainer) {
    const terminalHeight = terminalContainer.offsetHeight;
    const spacing = 8; // 添加8px的间距
    imagePreviewWrapper.style.bottom = (terminalHeight + spacing) + 'px';
    
    console.log('图片预览容器高度已更新:', {
      terminalHeight,
      spacing,
      newBottom: (terminalHeight + spacing) + 'px'
    });
  }
}

// 强制重置所有容器高度
function forceResetLayout() {
  console.log('=== 强制重置布局 ===');
  
  // 重置标签栏
  const tabBar = document.querySelector('.tab-bar');
  if (tabBar) {
    tabBar.style.height = '35px';
    tabBar.style.maxHeight = '35px';
    tabBar.style.minHeight = '35px';
  }
  
  // 重置标签列表
  const tabList = document.getElementById('tab-list');
  if (tabList) {
    tabList.style.height = '35px';
    tabList.style.maxHeight = '35px';
    tabList.style.minHeight = '35px';
  }
  
  // 重置编辑器区域
  const editorArea = document.querySelector('.editor-area');
  if (editorArea) {
    editorArea.style.flex = '1';
    editorArea.style.minHeight = '0';
  }
  
  // 重置终端容器
  const terminalContainer = document.getElementById('terminal-container');
  if (terminalContainer) {
    terminalContainer.style.height = '200px';
    terminalContainer.style.maxHeight = '200px';
    terminalContainer.style.minHeight = '150px';
  }
  
  // 重置所有标签页
  const allTabs = document.querySelectorAll('.tab');
  allTabs.forEach(tab => {
    tab.style.height = '35px';
    tab.style.maxHeight = '35px';
    tab.style.minHeight = '35px';
  });
  
  // 更新图片预览容器高度
  updateImagePreviewHeight();
  
  console.log('=== 布局重置完成 ===');
}

// 挂载到全局，供 HTML 事件调用
window.openWithExternalApp = openWithExternalApp;
window.testTabScrolling = testTabScrolling;
window.debugTabLayout = debugTabLayout;
window.forceResetLayout = forceResetLayout;
window.validateLineNumberAlignment = validateLineNumberAlignment;
window.testLineNumbers = function() {
  console.log('=== 测试行号系统 ===');
  updateLineNumbers();
  setTimeout(() => {
    validateLineNumberAlignment();
    forceSyncLineNumbersHeight();
    console.log('行号测试完成');
  }, 100);
};

// VSCode风格的行号测试函数
window.testLineNumberAlignment = function() {
  console.log('=== VSCode风格行号测试 ===');
  
  let codeEditor = document.getElementById('code-editor');
  const lineNumbers = document.querySelector('.line-numbers');
  const codeElement = codeEditor.querySelector('code');
  
  if (!codeEditor || !lineNumbers || !codeElement) {
    console.error('找不到编辑器或行号容器');
    return;
  }
  
  // 获取计算样式
  const computedStyle = window.getComputedStyle(codeElement);
  const lineHeight = parseInt(computedStyle.lineHeight) || 21;
  const fontSize = parseInt(computedStyle.fontSize) || 14;
  
  console.log('VSCode样式信息:', {
    lineHeight,
    fontSize,
    padding: computedStyle.padding,
    fontFamily: computedStyle.fontFamily,
    color: computedStyle.color
  });
  
  console.log('编辑器状态:', {
    scrollTop: codeEditor.scrollTop,
    scrollHeight: codeEditor.scrollHeight,
    clientHeight: codeEditor.clientHeight,
    transform: lineNumbers.style.transform
  });
  
  // 验证行号数量和样式
  const lines = codeElement.textContent.split('\n');
  const lineCount = lines.length;
  const lineNumberElements = lineNumbers.querySelectorAll('.line-number');
  const lineNumberCount = lineNumberElements.length;
  
  console.log('内容统计:', {
    codeLines: lineCount,
    lineNumbers: lineNumberCount,
    match: lineCount === lineNumberCount
  });
  
  // 检查VSCode风格的对齐
  const checkLines = Math.min(5, lineCount);
  let allAligned = true;
  
  for (let i = 1; i <= checkLines; i++) {
    const lineNumber = lineNumbers.querySelector(`[data-line="${i}"]`);
    if (lineNumber) {
      const topPosition = parseInt(lineNumber.style.top) || 0;
      const expectedTop = (i - 1) * lineHeight + 10;
      const isAligned = Math.abs(topPosition - expectedTop) <= 1;
      
      if (!isAligned) allAligned = false;
      
      console.log(`行 ${i} VSCode对齐检查:`, {
        actualTop: topPosition,
        expectedTop: expectedTop,
        isAligned: isAligned,
        difference: topPosition - expectedTop,
        textContent: lineNumber.textContent,
        dataLine: lineNumber.getAttribute('data-line')
      });
    }
  }
  
  // 检查当前行高亮
  const currentLine = lineNumbers.querySelector('.line-number.current-line');
  console.log('当前行高亮:', {
    hasCurrentLine: !!currentLine,
    currentLineNumber: currentLine ? currentLine.getAttribute('data-line') : null
  });
  
  // 检查整体高度
  const expectedHeight = lineCount * lineHeight + 20;
  const actualHeight = lineNumbers.offsetHeight;
  console.log('VSCode高度检查:', {
    expectedHeight,
    actualHeight,
    heightMatch: Math.abs(expectedHeight - actualHeight) <= 1
  });
  
  console.log('VSCode风格测试结果:', {
    allAligned: allAligned,
    style: 'VSCode风格',
    status: allAligned ? '✓ 完美对齐' : '✗ 需要调整'
  });
  
  console.log('=== VSCode风格测试完成 ===');
};

// 全局函数：强制重新计算行号系统
window.forceRecalculateLineNumbers = function() {
  console.log('=== 强制重新计算行号系统 ===');
  
  let codeEditor = document.getElementById('code-editor');
  const lineNumbers = document.querySelector('.line-numbers');
  
  if (!codeEditor || !lineNumbers) {
    console.error('找不到编辑器或行号容器');
    return;
  }
  
  // 获取当前状态
  const currentState = {
    editorScrollTop: codeEditor.scrollTop,
    editorScrollHeight: codeEditor.scrollHeight,
    editorClientHeight: codeEditor.clientHeight,
    lineNumbersHeight: lineNumbers.offsetHeight,
    lineNumbersTransform: lineNumbers.style.transform,
    totalLines: lineNumbers.children.length
  };
  
  console.log('重新计算前状态:', currentState);
  
  // 执行所有行号相关函数
  updateLineNumbers();
  preciseAlignLineNumbers(); // 确保精确对齐
  ensureScrollSync();
  forceRecalculateEditorScroll();
  forceSyncLineNumbersHeight();
  
  // 验证结果
  setTimeout(() => {
    const newState = {
      editorScrollHeight: codeEditor.scrollHeight,
      lineNumbersHeight: lineNumbers.offsetHeight,
      totalLines: lineNumbers.children.length
    };
    
    console.log('重新计算后状态:', newState);
    console.log('高度匹配:', Math.abs(newState.editorScrollHeight - newState.lineNumbersHeight) <= 1);
    console.log('行号数量正确:', newState.totalLines > 0);
  }, 100);
};

// 全局函数：测试终端提示符
window.testTerminalPrompt = function() {
  console.log('=== 测试终端提示符 ===');
  
  const inputPromptElement = document.querySelector('.terminal-input-line .terminal-prompt');
  const outputPromptElement = document.getElementById('terminal-prompt');
  
  console.log('当前工作目录:', terminalWorkingDir);
  console.log('输入框提示符元素:', inputPromptElement);
  console.log('输出区域提示符元素:', outputPromptElement);
  
  if (inputPromptElement) {
    console.log('输入框提示符内容:', inputPromptElement.textContent);
  }
  
  if (outputPromptElement) {
    console.log('输出区域提示符内容:', outputPromptElement.textContent);
  }
  
  // 测试更新提示符
  console.log('正在更新终端提示符...');
  updateTerminalPrompt();
  
  setTimeout(() => {
    console.log('更新后的输入框提示符:', inputPromptElement ? inputPromptElement.textContent : '未找到');
    console.log('更新后的输出区域提示符:', outputPromptElement ? outputPromptElement.textContent : '未找到');
    console.log('=== 测试完成 ===');
  }, 100);
};

// 全局函数：模拟切换目录
window.simulateChangeDirectory = function(newPath) {
  console.log('=== 模拟切换目录 ===');
  console.log('原工作目录:', terminalWorkingDir);
  console.log('新工作目录:', newPath);
  
  terminalWorkingDir = newPath;
  updateTerminalPrompt();
  
  console.log('目录切换完成，当前工作目录:', terminalWorkingDir);
  console.log('=== 模拟完成 ===');
};

// 全局测试函数：验证行号滚动同步
window.testLineNumberScroll = function() {
  console.log('=== 测试行号滚动同步 ===');
  
  let codeEditor = document.getElementById('code-editor');
  const lineNumbers = document.querySelector('.line-numbers');
  
  if (!codeEditor || !lineNumbers) {
    console.error('找不到编辑器或行号容器');
    return;
  }
  
  // 获取当前状态
  const currentState = {
    editorScrollTop: codeEditor.scrollTop,
    editorScrollHeight: codeEditor.scrollHeight,
    editorClientHeight: codeEditor.clientHeight,
    lineNumbersHeight: lineNumbers.offsetHeight,
    lineNumbersTransform: lineNumbers.style.transform,
    totalLines: lineNumbers.children.length
  };
  
  console.log('当前状态:', currentState);
  
  // 测试滚动到不同位置
  const testPositions = [0, 100, 200, 500, 1000];
  
  testPositions.forEach((scrollTop, index) => {
    setTimeout(() => {
      console.log(`测试滚动位置 ${index + 1}: ${scrollTop}px`);
      
      // 设置滚动位置
      codeEditor.scrollTop = scrollTop;
      
      // 手动触发滚动同步
      syncLineNumbersScroll();
      
      // 检查结果
      const newState = {
        editorScrollTop: codeEditor.scrollTop,
        lineNumbersTransform: lineNumbers.style.transform,
        expectedTransform: `translateY(-${scrollTop}px)`
      };
      
      console.log('滚动结果:', newState);
      
      // 验证transform是否正确
      const isCorrect = lineNumbers.style.transform === `translateY(-${scrollTop}px)`;
      console.log('Transform正确:', isCorrect);
      
    }, index * 500);
  });
  
  // 恢复原始位置
  setTimeout(() => {
    codeEditor.scrollTop = currentState.editorScrollTop;
    syncLineNumbersScroll();
    console.log('已恢复原始位置');
  }, testPositions.length * 500 + 500);
};

// VSCode风格的编辑器布局初始化
function initializeEditorLayout() {
  let codeEditor = document.getElementById('code-editor');
  const lineNumbers = document.querySelector('.line-numbers');
  const codeContent = document.querySelector('.code-content');
  
  if (codeEditor && lineNumbers && codeContent) {
    // VSCode风格：移除固定的最小高度设置，让内容自然决定高度
    codeEditor.style.minHeight = '';
    codeEditor.style.height = '100%';
    
    // 确保行号容器样式正确
    lineNumbers.style.position = 'absolute';
    lineNumbers.style.left = '0';
    lineNumbers.style.top = '0';
    lineNumbers.style.width = '50px';
    lineNumbers.style.background = '#1e1e1e';
    lineNumbers.style.borderRight = '1px solid #3c3c3c';
    lineNumbers.style.overflow = 'hidden';
    lineNumbers.style.zIndex = '1';
    
    console.log('VSCode风格编辑器布局初始化完成');
  }
}

// 初始化编辑器滚动同步
function initializeEditorScrollSync() {
  const codeEditor = document.getElementById('code-editor');
  if (codeEditor) {
    codeEditor.addEventListener('scroll', syncLineNumbersScroll);
    console.log('编辑器滚动同步已初始化');
  }
}

// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', function() {
  console.log('开始页面初始化...');
  
  // 初始化编辑器滚动同步
  initializeEditorScrollSync();
  
  // 初始化其他功能
  if (typeof initTabScrolling === 'function') {
    initTabScrolling();
  }
  if (typeof initSidebarResizer === 'function') {
    initSidebarResizer();
  }
  if (typeof initTerminalResizer === 'function') {
    initTerminalResizer();
  }
  if (typeof initContextMenu === 'function') {
    initContextMenu();
  }
  if (typeof initializeMenuBar === 'function') {
    initializeMenuBar();
  }
  if (typeof initializeCodeEditor === 'function') {
    initializeCodeEditor();
  }
  
  // 初始化关于模态弹窗
  initAboutModal();
  
  // 初始化文件系统
  if (typeof FileSystem !== 'undefined') {
    fileSystem = new FileSystem();
    fileSystem.initialize().then(() => {
      console.log('文件系统初始化完成');
      initializationComplete = true;
      ensureWindowShown();
      // 初始化欢迎语句显示状态
      updateWelcomeMessage();
    }).catch(error => {
      console.error('文件系统初始化失败:', error);
      initializationComplete = true;
      ensureWindowShown();
      // 初始化欢迎语句显示状态
      updateWelcomeMessage();
    });
  } else {
    console.log('FileSystem 类不可用，跳过文件系统初始化');
    initializationComplete = true;
    ensureWindowShown();
    // 初始化欢迎语句显示状态
    updateWelcomeMessage();
  }
  
  console.log('页面初始化完成');
});

// 调试行号容器状态
window.debugLineNumbers = function() {
  console.log('=== 行号容器调试 ===');
  
  const lineNumbers = document.querySelector('.line-numbers');
  const codeEditor = document.getElementById('code-editor');
  const codeElement = codeEditor ? codeEditor.querySelector('code') : null;
  
  console.log('行号容器元素:', lineNumbers);
  console.log('代码编辑器元素:', codeEditor);
  console.log('代码元素:', codeElement);
  
  if (lineNumbers) {
    const computedStyle = window.getComputedStyle(lineNumbers);
    console.log('行号容器样式:', {
      display: computedStyle.display,
      visibility: computedStyle.visibility,
      opacity: computedStyle.opacity,
      position: computedStyle.position,
      left: computedStyle.left,
      top: computedStyle.top,
      width: computedStyle.width,
      height: computedStyle.height,
      zIndex: computedStyle.zIndex,
      backgroundColor: computedStyle.backgroundColor,
      borderRight: computedStyle.borderRight
    });
    
    console.log('行号容器内HTML:', lineNumbers.innerHTML);
    console.log('行号元素数量:', lineNumbers.children.length);
    
    // 检查是否有行号元素
    const lineNumberElements = lineNumbers.querySelectorAll('.line-number');
    console.log('行号元素:', lineNumberElements);
    lineNumberElements.forEach((el, index) => {
      console.log(`行号 ${index + 1}:`, {
        textContent: el.textContent,
        display: window.getComputedStyle(el).display,
        color: window.getComputedStyle(el).color
      });
    });
  }
  
  if (codeElement) {
    const content = codeElement.textContent;
    const lines = content.split('\n');
    console.log('代码内容行数:', lines.length);
    console.log('代码内容前几行:', lines.slice(0, 5));
  }
  
  console.log('=== 调试完成 ===');
};

// VSCode风格的行号显示
window.forceShowLineNumbers = function() {
  console.log('VSCode风格行号显示...');
  
  const lineNumbers = document.querySelector('.line-numbers');
  if (lineNumbers) {
    // VSCode风格：确保行号容器可见
    lineNumbers.style.display = 'block';
    lineNumbers.style.visibility = 'visible';
    lineNumbers.style.opacity = '1';
    lineNumbers.style.background = '#1e1e1e';
    lineNumbers.style.borderRight = '1px solid #3c3c3c';
    
    // 强制更新行号
    updateLineNumbers();
    preciseAlignLineNumbers(); // 确保精确对齐
    
    console.log('VSCode风格行号已显示');
  } else {
    console.error('找不到行号容器');
  }
};

// VSCode风格的行号重置
window.resetVSCodeLineNumbers = function() {
  console.log('重置VSCode风格行号...');
  
  const lineNumbers = document.querySelector('.line-numbers');
  if (lineNumbers) {
    // 清空所有行号
    lineNumbers.innerHTML = '';
    lineNumbers.style.height = '0px';
    lineNumbers.style.transform = '';
    
    // 重新初始化
    updateLineNumbers();
    preciseAlignLineNumbers();
    
    console.log('VSCode风格行号已重置');
  } else {
    console.error('找不到行号容器');
  }
};
